Ви навчаєте клас учнів із цікавими уподобаннями того, як влаштовані їхні стільці. Існують 3 дуже специфічні вимоги щодо розташування стільців:

1. Вони найбільш розташовані у прямокутнику, навіть якщо це означає, що деякі стільці залишаються порожніми.

2. Повинно бути якомога менше порожніх стільців.

3. Вони повинні бути максимально «квадратними». Квадратність визначається відстанню між шириною та висотою прямокутника, нижче нижча. Наприклад, прямокутник, який є, 4x7має прямокутність 3.

Якщо бути більш конкретним, "оцінка" розташування - це відстань між шириною і висотою плюс кількість стільців, які будуть порожніми.

Візьмемо приклад. Скажімо, у вас 13 учнів. Ви можете влаштувати стільці будь-яким із цих способів:

1x13
2x7
3x5
4x4

1x13не дуже просторий. Насправді 1 і 13 розташовані на 12 один від одного, тому ми даємо цю домовленість 12 балів. У нього також є 0 порожніх стільців, тому ми додаємо 0 балів, даючи цьому розташуванню бал 12. Не так вже й чудово.

2x7це, звичайно, краще. 2 і 7 - лише 5 один від одного, тому ми даємо цій домовленості 5 балів. Однак якщо ви насправді влаштували 2 ряди семи стільців, це займе 14 стільців, значить, один стілець буде порожнім. Тож ми додаємо один бал, даючи цій схемі оцінку 6.

Ми також могли б зробити 3x5. 3 і 5 - 2 однакові, тому +2 бали. Це займає 15 стільців, це означає, що у нас буде два зайвих крісла, тож ще +2 бали, за рахунок 4.

Останній варіант, 4x4. 4 і 4 - один від одного, тому ми даємо це +0 балів. 4x4 займає 16 стільців, тому 3 стільці залишаються порожніми, загальна оцінка 3. Це оптимальне рішення.

У випадку краватки, оптимальне рішення - рішення з менш порожніми стільцями.

Змагання

Ви повинні написати програму або функцію, яка займає ціле число і виводить оптимальне розташування стільців для такої кількості студентів. IO може бути в будь-якому розумному форматі. Ось вибірки для будь-якої кількості студентів від 1 до 100:

1:  (1, 1)
2:  (1, 2)
3:  (2, 2)
4:  (2, 2)
5:  (2, 3)
6:  (2, 3)
7:  (3, 3)
8:  (3, 3)
9:  (3, 3)
10: (2, 5)
11: (3, 4)
12: (3, 4)
13: (4, 4)
14: (4, 4)
15: (4, 4)
16: (4, 4)
17: (3, 6)
18: (3, 6)
19: (4, 5)
20: (4, 5)
21: (3, 7)
22: (5, 5)
23: (5, 5)
24: (5, 5)
25: (5, 5)
26: (4, 7)
27: (4, 7)
28: (4, 7)
29: (5, 6)
30: (5, 6)
31: (4, 8)
32: (4, 8)
33: (6, 6)
34: (6, 6)
35: (6, 6)
36: (6, 6)
37: (5, 8)
38: (5, 8)
39: (5, 8)
40: (5, 8)
41: (6, 7)
42: (6, 7)
43: (5, 9)
44: (5, 9)
45: (5, 9)
46: (7, 7)
47: (7, 7)
48: (7, 7)
49: (7, 7)
50: (5, 10)
51: (6, 9)
52: (6, 9)
53: (6, 9)
54: (6, 9)
55: (7, 8)
56: (7, 8)
57: (6, 10)
58: (6, 10)
59: (6, 10)
60: (6, 10)
61: (8, 8)
62: (8, 8)
63: (8, 8)
64: (8, 8)
65: (6, 11)
66: (6, 11)
67: (7, 10)
68: (7, 10)
69: (7, 10)
70: (7, 10)
71: (8, 9)
72: (8, 9)
73: (7, 11)
74: (7, 11)
75: (7, 11)
76: (7, 11)
77: (7, 11)
78: (9, 9)
79: (9, 9)
80: (9, 9)
81: (9, 9)
82: (7, 12)
83: (7, 12)
84: (7, 12)
85: (8, 11)
86: (8, 11)
87: (8, 11)
88: (8, 11)
89: (9, 10)
90: (9, 10)
91: (7, 13)
92: (8, 12)
93: (8, 12)
94: (8, 12)
95: (8, 12)
96: (8, 12)
97: (10, 10)
98: (10, 10)
99: (10, 10)
100: (10, 10)

Як завжди, це код-гольф, тому застосовуються стандартні лазівки, а переможець - найкоротша відповідь у байтах.

Желе , 16 15 14 байт

÷RĊ,Rµạ/+PỤḢịZ

Спробуйте в Інтернеті! або перевірити всі тестові випадки .

Як це працює

÷RĊ,Rµạ/+PỤḢịZ  Main link. Argument: n

 R              Range; yield [1, ..., n].
÷               Divide n by each k in [1, ..., n].
  Ċ             Ceil; round the quotients up to the nearest integer.
    R           Range; yield [1, ..., n].
   ,            Pair; yield A := [[ ⌈n ÷ 1⌉, ..., ⌈n ÷ n⌉ ], [ 1, ..., n ]].
     µ          Begin a new, monadic chain. Argument: A
      ạ/        Reduce A by absolute difference.
                This yields [ |⌈n ÷ 1⌉ - 1|, ..., |⌈n ÷ n⌉ - n| ].
         P      Product; reduce A by multiplication.
                This yields [ ⌈n ÷ 1⌉ × 1, ..., ⌈n ÷ n⌉ × n].
       +        Add the results to left and right, element by element. This yields
                [ |⌈n ÷ 1⌉ - 1| + ⌈n ÷ 1⌉ × 1, ..., |⌈n ÷ n⌉ - n| + ⌈n ÷ n⌉ × n ].
          Ụ     Grade up; sort the indices of the list of sums by their values.
           Ḣ    Head; extract the first value, which corresponds to the smallest
                sum. Grading up is stable, so this selects the first index of all
                with the smallest sum in case of a tie. In this event, the first
                index will have the highest absolute difference of all indices
                with the smallest sum, meaning that it has the lowest product and,
                therefore, the lowest number of empty chairs.
             Z  Zip; transpose A's rows and columns.
                This yields [[ ⌈n ÷ 1⌉, 1 ], ..., [ ⌈n ÷ n⌉, n ]].
            ị   Retrieve the pair at that index.

Python 2, 68 байт

lambda n:min((abs(~i-n/~i)+n/~i*~i,i+1,0-n/~i)for i in range(n))[1:]

Еквівалентно більш "очевидним":

lambda n:min([(i+1,0-n/~i)for i in range(n)],key=lambda(p,q):abs(p-q)+p*q)

Haskell, 65 байт

f x=snd$minimum[((a*b+a-b,a*b),(b,a))|a<-[1..x],b<-[1..a],a*b>=x]

Приклад використання: map f [1..5]-> [(1,1),(1,2),(2,2),(2,2),(2,3)].

Проходить через зовнішню петлю aвід 1до x(x -> кількість учнів) та внутрішню петлю bвід 1до a. Зберігає всі, (b,a)де a*b>=xі будує пари, ((arrangement points,seats left), (b,a))які слідують лексикографічному порядку, який нам потрібен, щоб знайти мінімум. Примітка: aзавжди більше ніж b, тому нам не потрібно absквадратичності. Не потрібно віднімати xвід оцінки "лівих місць", тому що має значення лише відносний порядок. Нарешті ми видаляємо парну оцінку за допомогою snd.

Рубін, 64 байти

->n{(1..n).map{|w|h=(n+w-1)/w;[(h-w).abs+h*w,w*h,w,h]}.min[2,3]}

Лямбада, яка сприймає кількість людей як аргумент і повертає масив із шириною та висотою оптимального рішення.

MATL , 18 байт

:Gy/Xkvtd|yp+&X<Z)

Спробуйте в Інтернеті!

Пояснення

:      % Implicit input number N. Range [1 2 ... N]
G      % Push N again
y      % Duplicate second-from-top: push [1 2 ... N] again
/Xk    % Divide and round up
v      % Vertically concatenate. Gives 2×N array of rectangle sizes
td|    % Duplicate. Absolute difference of each column
y      % Duplicate second-from-top: push 2×N array again
p      % Product of each column
+      % Sum absolute differences and products
&X<    % Arg min
Z)     % Use as column index into the 2×N array. Implicitly display

Javascript, 98 байт

Мій перший гольф-код, тому я все-таки публікую!

f=n=>{for(o=1/0,i=1;i<=n;i++)for(j=n;i*j>=n;j--)t=i*j-n+Math.abs(i-j),o>t&&(o=t,a=[i,j]);return a}

Спочатку мій oбув порожнім об'єктом, і я перевірив, чи o.aвін порожній, тому це був особливий випадок на першому раунді. Але я знайшов фокус 1/0 у відповіді edc65 на ініціалізацію змінної до Infinity.

Pyth, 24 22 21 байт

Редагувати : в клавіші сортування я розумію, що немає необхідності знаходити кількість порожніх стільців. Це рівнозначно балу загальної кількості стільців. Це врятувало мені 2 байти.

h.m_+B*FbaFbm,d.EcQdS

Спробуйте в Інтернеті!

Матлаб(174) (146)121

  function g(n),f=@(n,i)ceil(n/i);x=[];for i=1:n,x=[sortrows(x); f(n,i)*i-1/(f(n,i)*i)+abs(f(n,i)-i) i f(n,i)];end,x(1,2:3)

• трюк 1: я додав суму 1-1/length*widthяк підрахунок рахунків

• трюк 2: я обчислював number_students/lengthстелю для ширини прямокутника, верхня межа - квадрат, але стеля теж

• Я впевнений, що далі можна пограти в гольф ...

Спробуй це

Редагувати: посилається на зауваження @StewieGriffin.

Редагувати 2:

• 1і nє константами, не потрібно додавати їх до загальної оцінки.
• Функція на кілька байтів менше, ніж окрема програма stdin.
• Я використав техніку сортування висхідних, але це економить занадто багато байт

Правка 3: тест на відповідність.

Python 2, 64 байти

lambda n:max((~-i*~min(i,n/i),0-n/i,-i)for i in range(-n,0))[1:]

Це об'єднання відповіді Python @ Lynn (звідки я взяв max(...)[1:]трюк) та алгоритму з моєї відповіді Джулії (що дозволяє трохи коротше реалізувати).

Перевірте це на Ideone .

Юлія, 61 59 55 53 52 байт

/ =cld
n->[m=indmax([~i*~-max(i,n/i)for i=1:n]),n/m]

Спробуйте в Інтернеті!

Як це працює

Код еквівалентний наступній версії, що не cldмає вольфів, де поділ на стелі.

function chairs(n)
    m = indmin([(i + 1) * (max(i, cld(n, i)) - 1) for i in 1:n])
    return [m, cld(n, m)]
end

Щоб знайти оптимальне розташування, однозначно достатньо вивчити пари [i, j] , де 1 ≤ i ≤ n і j = ⌈n / i⌉ .

Оцінка такої композиції дорівнює | j - i | + (ij - n) , де другий підсумок - кількість порожніх стільців. Замість фактичних балів ми можемо порівняти оцінки, збільшені на константу, такі як ij + | j - i | + 1 .

Досить розглянути пари [i, j], де i ≤ j з моменту розташування [i, j] і [j, i] однаково справедливі. Ми маємо справу зі строго низхідними парами, встановлюючи натомість j = max (⌈n / i⌉, i) , що гарантує, що j ≥ i і дасть неоптимальний бал, якщо ⌈n / i⌉ <i .

Оскільки j - i ≥ 0 , маємо ij + | j - i | + 1 = ij + j - i + 1 = (i + 1) × (j - 1) , який можна обчислити в меншій кількості байтів коду.

Нарешті indmin/ indmaxдає індекс m (і, таким чином, значення i ) оптимального розташування, яке m на ⌈n / m⌉ . Зв'язки розриваються при першому виникненні, що відповідає найменшому значенню i , отже, найвищому значенню j - i а отже, найменшому значенню ij - n (порожні стільці).

JavaScript (ES6) 74 78

Редагуйте, зберігаючи результат temp як масив замість 2 vars, запозичений з відповіді Thiht

n=>(z=>{for(x=0;y=-~(~-n/++x),x<=y;)(s=y-x+x*y-n)>=z||(z=s,r=[x,y])})()||r

Менше гольфу

n=>{
  z = 1/0
  for (x=0; y=(n-1)/++x+1|0, x <= y; )
  {
    s = y-x+x*y-n;
    if (s<z)
      z=s, r=[x,y]
  }
  return r
}

Тест

f=n=>(z=>{for(x=0;y=-~(~-n/++x),x<=y;)(s=y-x+x*y-n)>=z||(z=s,r=[x,y])})()||r

out=x=>O.textContent+=x+'\n'

for(i=1;i<=100;i++)out(i+' :( '+f(i)+' )')

<pre id=O></pre>

PHP, 129 байт

function f($i){$s=INF;for($x=1;$x<$i;$x++){if($s>$t=(abs($x-$e=ceil($i/$x))-$i+($e*$x))){$s=$t;$d[0]=$x;$d[1]=$e;}}var_dump($d);}

Безголівки:

function f ($i){
    $s=INF;
    for($x=1; $x<$i; $x++){ // for every number less than the input
        if( $s > $t=( abs($x-$e=ceil($i/$x))-$i+($e*$x) ) ){ 
            // determine the other dimension, the score, and compare to the minimum score
            $s=$t;
            $d[0]=$x;
            $d[1]=$e;
        }
    }
    var_dump($d);
}

PHP, 104 байти

Алгоритм, який вирішує цю проблему, простий і, ймовірно, використовується іншими відповідями мовами, схожими на PHP (JavaScript, fe):

• почніть з великого значення для початкової оцінки; nдосить велика (де nвхідне значення); оцінка розташування, обчислена на першій ітерації ( 1, n), є(n-1)+0 ;
• ітерація всіх значень ширини між 1і n; обчислити мінімальну висоту як ceil(n/width), обчислити бал розташування, використовуючи формулу, подану у запитанні (тобто abs(width - height) + (width * height - n)); якщо оцінка краща за попередній найкращий результат, тоді пам’ятайте про ширину, висоту та новий найкращий бал; на зв'язках використовують значенняwidth * height - n поточного розташування та попереднього найкращого розташування для виявлення нового найкращого розташування;
• це все.

Після гри в гольф цей алгоритм виробляє щось подібне (обгорнуте тут для читання):

for($s=$h=$j=$n=$argv[$w=$i=1];$i<=$j;$j=ceil($n/++$i)
{$c=$j-$i+$i*$j-$n;if($c<$s||$c==$s&&$i*$j<$w*$h){$w=$i;$h=$j;$s=$c;}}
echo"$w,$h";

Він використовує 137 байт (якщо їх розміщують в одному рядку), і це далеко не 104 байти, розміщені в заголовку. Код, можливо, може бути скорочений ще на 2-3 байти, але велике джерело вдосконалення - десь в іншому місці: в деталях алгоритму.

Перероблений алгоритм:

Є кілька місць, де алгоритм можна вдосконалити, видаливши марний код.

• немає необхідності переробляти ширину від 1до $n; для швидкості, ширина ( $i) повинна ітерацію між 1і , floor(sqrt($n))але це робить код ще більше замість того , щоб скоротити його; але якщо ширина не перевищує sqrt($n), мінімальна висота ( $j) завжди буде більше, ніж sqrt($n)(їх виріб повинен бути не менше$n );
• попереднє твердження дозволяє використовувати $i <= $j(ширина <= висота) як умову завершення циклу; таким чином, ширина буде ітератувати від 1до, floor(sqrt($n))а висота отримає значення, починаючи з $nта знижуючись доceil(sqrt($n)) (не обов'язково всі);
• знаючи, що ширина завжди менша або дорівнює висоті, дозволяють нам знати, що abs(width - height)це завжди height - width($j-$i ); 5 байтів збережено таким чином;
• вхідне значення $nвикористовується при обчисленні балу (кількість незайнятих місць width * height - n), але воно не потрібне; оцінка не потребує відображення, вона обчислюється лише для порівняння домовленостей; видаляючи - nз формули оцінки, ми зберігаємо ще 3 байти (код PHP -$n), не втрачаючи нічого;
• враховуючи останні два твердження, формула балів стає height - width + width * height($j-$i+$i*$j );
• щодо зв'язків (оцінка поточної композиції така ж, як і попередня найкраща оцінка) правила говорять про використання домовленостей з меншим вільним сидінням; оскільки ширина завжди збільшується, а висота завжди зменшується, тоheight - width частина оцінки зменшується на кожному кроці;
• якщо поточний бал дорівнює попередньому найкращому балу, попередні висловлювання говорять нам про те, що кількість вільних місць в поточному розташуванні більша, ніж у попереднього найкращого бала; це означає, що попередня найкраща домовленість виграла нічию;
• оскільки зв'язки завжди виграються за попередньою найкращою домовленістю, нова композиція стає новою найкращою композицією лише тоді, коли її оцінка менша, ніж попередня найкраща; код, який перевіряє зв'язки, марний і його можна видалити ( ||$c==$s&&$i*$j<$w*$h- багато байт);
• через вилучення -$nз формули балів оцінка за перше розташування ( 1x$n) дорівнює $n-1+1*$n(тобто 2*$n-1); початкове значення найкращої оцінки ( $s) може бути будь-яким значенням, більшим або рівним 2*$n; перша ітерація має кращу оцінку, і вона стає найкращою домовленістю, дозволяючи алгоритму працювати без проблем з ініціалізацією.

Новий код ( 104 байти ) після застосування описаних вище поліпшень:

for($s=2*$j=$n=$argv[$i=1];$i<=$j;$j=ceil($n/++$i))
if($s>$c=$j-$i+$i*$j){$w=$i;$h=$j;$s=$c;}echo"$w,$h";

Тут обгорнуто для читабельності. Додайте код вище за допомогою маркера PHP <?php(технічно він не є частиною коду), введіть його у файл (скажімо arrange-your-chairs.php) та запустіть його з цілим числом, більшим за нуль як аргумент. Він відображатиме ширину та висоту обчисленої компоновки, розділених комою:

$ php arrange-your-chairs.php 1001
28,36

Ще одне рішення (116 байт)

Ще одне рішення, яке використовує інший алгоритм:

for($n=$argv[1];++$j<=$n;)for($i=0;++$i<=$j;)
if($n<=$k=$i*$j)$a["$i,$j"]=($j-$i+$k-$n)*$n+$k;asort($a);echo key($a);

Він ставить усі комбінації принаймні $n місць у асоціативний список; ключ - це текстове подання розташування, значення - оцінка балів. Потім він сортує список (за зростанням за значенням) і отримує ключ першого запису.

Ще один (115 байт)

foreach(range(1,$m=$n=$argv[1])as$i)
if(($d=ceil($n/$i))<=$i&&$m>=$s=$i*$d-$n+$i-$d){$m=$s;$w=$d;$h=$i;}echo"$w,$h";

Це PHP версія @ Нейл відповіді (JavaScript / ES6, 85 байт).

Існують деякі помітні відмінності через особливості кожної мови:

• відповідь JS генерує масив n(невизначених) значень, потім використовує свої ключі для ітерації від 0до n-1; він збільшує i( d=(n+i++)/i|0) , щоб зробити його ітерацію від 1до n; Рішення PHP не потрібно збільшувати; він використовує range()для створення масиву, тоді він використовує генеровані значення ( 1доn ) для ітерації;
• відповідь JS використовує (n+i)/iпотім перетворює значення в ціле число, використовуючи |0для отримання найменшого цілого числа більше, ніж n/i; відповідь PHP вирішує це питання легко за допомогою функції PHP ceil(); JavaScript також надає, Math.ceil()але він використовує 5 байт більше, ніж рішення, знайдене Нілом;
• PHP забезпечує функцію, array_map()яка якось схожа на JS, Array.map()але вона тут не допомагає; його синтаксис є багатослівним, а foreachутворює коротший код; він більший, ніж код JS;
• об'єднання призначень з умовами використання ||неможливо в PHP, оскільки в ньому відсутній оператор комами; Я переклав a||b||cна if(!a&&!b)cпотім, тому що aі bє порівняннями, я заперечував їхніх операторів (замінювався <на >=); це також створює більший код, ніж версія JS;
• ще 23 байти потрібно додати лише тому, що назви змінних у PHP повинні бути встановлені префіксом $.

Невикористані версії всіх рішень та тестовий набір можна знайти на Github .

JavaSCript (ES6), 83 байти

n=>[...Array(m=n)].map((_,i)=>(d=(n+i++)/i|0)>i||(s=i*d-n+i-d)>m||(m=s,r=[d,i]))&&r

Юлія, 87 років

Я думаю, що це один крок у напрямку пошуку магічної функції для проблеми:

f(i)=(i+n)÷(i+1)|>j->(j*i<n)+j
_=indmin([sqrt(n)<=i?i-f(i)*(1-i):2n for i=1:n])
_,f(_)

Це дивиться лише на пари (i, j=(i+n)/(i+1))або(i, j+1)

Oracle SQL 11.2, 173 байт

SELECT MIN(x||','||y)KEEP(DENSE_RANK FIRST ORDER BY y-x+(y*x-:1))FROM(SELECT CEIL(LEVEL/:1)x,CEIL(MOD(LEVEL+.1,:1))y FROM DUAL CONNECT BY LEVEL<=:1*:1)WHERE x<=y AND:1<=x*y;

Без гольфу

SELECT MIN(x||','||y)KEEP(DENSE_RANK FIRST ORDER BY y-x+(y*x-:1))  -- Keeps the minimal score
FROM   (SELECT CEIL(LEVEL/:1)x,CEIL(MOD(LEVEL+.1,:1))y FROM DUAL CONNECT BY LEVEL<=:1*:1) -- Generate x,y combinations 
WHERE  x<=y AND :1<=x*y  -- Filters out wrong combinations

Q 58 байт

{c@d?&/d:+/(-/;*/)@\:+c:{((b<a)?1b)#+(b:-_-x%a;a:1+!x)}x}

Ламба, яка обчислює мінімальну вартість для заданого значення (x) і повертає послідовність двох значень (ширина, висота)

Для додавання імені до цієї лямбда потрібні два інші знаки (наприклад, f: {..} замість {..})

Тест

{..}'1+!100

де {..} лямбда. Читайте як "застосовується лямбда до кожного значення 1 + перших 100 інт" (іншими словами до кожного значення 1..100)

Породжує

1 1
2 1
2 2
2 2
3 2
3 2
3 3
3 3
3 3
5 2
4 3
4 3
4 4
4 4
4 4
4 4
6 3
6 3
5 4
5 4
7 3
5 5
..

Пояснення

Вкладене lamdba {((b<a)?1b)#+(b:-_-x%a;a:1+!x)}генерує всіх кандидатів (ширина, висота) пар для x стільців у вигляді двох послідовностей (w1 w2 w3 ..; h1 h2 h3 ..) (ширини та висоти). Читати зліва направо, але оцінювати справа наліво

a:1+!x генерує значення 1..x і присвоює цю послідовність a

-_- є запереченням підлоги негативом, а реалізує стелю (стеля не є примітивом мови)

b:-_-x%aзастосовує ceil до кожного значення x, поділеного на будь-який елемент im a, і присвоює отриману послідовність b. Іншими словами, b - стеля кожен x розділенийBy кожен 1..x

+(b;a) повернути послідовність, що складається з seq a і seq b, а потім перевертає її (результат - послідовність пари, де i-пара містить елемент i з a і елемент i з b)

b<a порівнює елемент за пунктами b і a і створює послідовність логічних значень (true = 1b для кожного індексу, де b [i]

s?xповертає перше положення елемента x у послідовності s. За допомогою (b<a)?1bШукаємо 1b (справжнє значення) в послідовності, що є результатом порівняння b і a, і отримуємо першу позицію, де b

n#sбере n перших n елементів з послідовностей s. Ми хочемо відкинути повторювані пари, тому ми зупиняємось, коли перший елемент пари <другий елемент (наприклад, розглянемо 13,1, але не 1,13).

Як побічний ефект, кожна пара результуючої послідовності має відстань між a і b (наприклад (13 1; 7 2; 5 3; 4 4)

Пара кандидатів, породжена вкладеною лямбда, присвоюється c. Потім перевертаємо c (отримує b, a знову) і застосовуємо до цього аргументу дві функції: */перемножуємо і -/віднімаємо. Результат (-/;*/)@\:+c- різниця та продукт кожної пари.+/підсумовується і обчислює остаточну вартість. Вартість кожного пацієнта призначається d

& / мінімально перевищує, тому &/d - мінімальна вартість. Коли d?&/dми знаходимо перше виникнення мінімальної вартості в d, а з c @ .. ми отримуємо пару в цій позиції. Оскільки кожна пара зменшує відстань між a і n, перший знайдений мінімум має максимальне відстань між іншими мінімальними парами, тому ми правильно застосовуємо правило tie