Давши піраміду додавання , визначте, чи можна її вирішити. Піраміда додавання складається з шарів , кожен з яких на одне число менше, ніж той, що знаходиться під ним. Шар символізується як . - базовий шар, а - шар на вершині . й номер позначається як . - найлівіше число , а - число праворуч від . Ви можете візуалізувати знаходиться поверх$P$$i$$P_i$$P_1$$P_{i+1}$$P_i$$j$$P_i$$P_{i,j}$$P_{i,1}$$P_i$$P_{i,j+1}$$P_{i,j}$$P_{i+1,j}$$P_{i,j}$і посередині, звідси і назва " піраміда додавання ".$P_{i,j+1}$

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$ , тобто кожне число в піраміді є ненульовим додатним цілим числом.
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$ , тобто кожне число, що не знаходиться на базовому шарі піраміди, є сумою два числа під ним.
• Якщо має чисел, має числа, тому - це найправіше число . Простіше кажучи, кожен шар має на одне число менше, ніж шар під ним.$P_1$$n$$P_i$$n-i+1$$P_{i,n-i+1}$$P_i$

Додаток піраміди-головоломки - це додаткова піраміда з деякими числами, видаленими (заміненими ). Її рішення - це піраміда додавання , де , тобто числа, які були спочатку присутні у головоломці залишилися без змін. Така головоломка може мати більше одного рішення.$Q$$?$$P$$\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$

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

Вхідні дані

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

• Масив шарів.
• Масив шарів, що мають форму піраміди, використовуючи послідовне непозитивне ціле значення як роздільник між елементами (використовується лише один раз кожного разу), а також лівою та правою накладками. Сепаратор і прокладка повинні бути однаковими.
• Масив шарів з послідовною дійсною правою чи лівою підкладкою (ви повинні бути послідовними, а не змішувати правий і лівий накладки в цьому випадку).

Зауважте, що для представлення відсутнього числа необхідно використовувати послідовне значення, яке не є суто позитивним цілим числом; це значення не можна використовувати як накладку. Крім того, ви можете взяти шари, з'єднані (ви можете ще їх розділити), і впорядкування може бути або від основи до верху, або від верху до основи.

Вихідні дані

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

Правила

• $Q_{i+1,j}=Q_{i,j}+Q_{i,j+1}$ завжди буде істинним, якщо , тобто вхід гарантується, що не буде містити номер над двома іншими числами, що не є їх сумою, якщо всі три числа відомі.$Q_{i,j},Q_{i,j+1},Q_{i+1,j}\in\mathbb N^*$
• $\exists Q_{i,j},Q_{i,j}\ne{?}$ , тобто піраміда буде містити щонайменше одне відоме число.
• Не роби цього .
• Це код-гольф , тому найкоротша відповідь виграє! Однак не дозволяйте це відштовхувати вас від публікації рішення лише тому, що ваша мова "занадто багатослівна".

Тестові справи

Масив із шарами зверху до основи використовується для цих тестових випадків, із 0поданням.$?$

[[10], [0, 0], [0, 2, 0], [0, 0, 0, 1]] -> True
[[32], [0, 0], [0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]] -> True
[[0], [1, 1]] -> True
[[1], [0, 0]] -> False
[[10], [5, 5], [2, 3, 2], [0, 0, 0, 0]] -> False
[[5], [0, 0], [0, 0, 0]] -> False

Працювали приклади

Тут працюють оглядові тести.

Унікальне рішення 1

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&?\\?&&?&&?&&1\end{array}$$

Крок 1: .$x+y=2\leftrightarrow x=y=1$

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&?\\?&&\color{red}1&&\color{red}1&&1\end{array}$$

Крок 2: .$x=y=1\leftrightarrow x+y=2$

$$\begin{array}c&&&10\\&&?&&?\\&?&&2&&\color{red}2\\?&&1&&1&&1\end{array}$$

Крок 3: .$x=y=2\rightarrow x+y=4$

$$\begin{array}c&&&10\\&&?&&\color{red}4\\&?&&2&&2\\?&&1&&1&&1\end{array}$$

Крок 4: .$x+4=10\leftrightarrow x=6$

$$\begin{array}c&&&10\\&&\color{red}6&&4\\&?&&2&&2\\?&&1&&1&&1\end{array}$$

Кроки 5-6 схожі на 4.

$$\begin{array}c&&&10\\&&6&&4\\&\color{red}4&&2&&2\\\color{red}3&&1&&1&&1\end{array}$$

Тож тут у нас є наше унікальне рішення.

Унікальне рішення 2

$$\begin{array}c&&&&&32\\&&&&?&&?\\&&&?&&?&&?\\&&?&&?&&?&&?\\&?&&?&&?&&?&&?\\?&&?&&?&&?&&?&&?\end{array}$$

Крок 1: Тут очевидного підходу немає, тому спробуємо використати мінімально можливі значення.

$$\begin{array}c&&&&&32\\&&&&?&&?\\&&&?&&?&&?\\&&?&&?&&?&&?\\&?&&?&&?&&?&&?\\\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1\end{array}$$

Кроки 2-5: Схоже, що мінімальні значення призводять до рішення, тому це єдине рішення і тому унікальне.

$$\begin{array}c&&&&&32\\&&&&\color{red}{16}&&\color{red}{16}\\&&&\color{red}8&&\color{red}8&&\color{red}8\\&&\color{red}4&&\color{red}4&&\color{red}4&&\color{red}4\\&\color{red}2&&\color{red}2&&\color{red}2&&\color{red}2&&\color{red}2\\1&&1&&1&&1&&1&&1\end{array}$$

Підказка: Існує теорема про складання пірамідних головоломок, пов’язаних із цією головоломкою, яку ви можете довести, якщо ви думаєте досить важко.

Унікальне рішення 3

$$\begin{array}c&?\\1&&1\end{array}$$

Крок 1: .$x=y=1\rightarrow x+y=2$

$$\begin{array}c&\color{red}2\\1&&1\end{array}$$

Це, очевидно, унікальне рішення.

Немає рішення 1

$$\begin{array}c&1\\?&&?\end{array}$$

$\min\mathbb N^*=1\rightarrow x,y\ge1\rightarrow x+y\ge2>1$ , тому рішення немає.

Немає рішення 2

$$\begin{array}c&&&10\\&&5&&5\\&2&&3&&2\\?&&?&&?&&?\end{array}$$

Кроки 1-2: .$x+y=2\leftrightarrow x=y=1$

$$\begin{array}c&&&10\\&&5&&5\\&2&&3&&2\\\color{red}1&&\color{red}1&&\color{red}1&&\color{red}1\end{array}$$

Звідси випливає, що , що є суперечливістю, тому рішення немає.$1+1=3$

Не унікальне рішення

$$\begin{array}c&&5\\&?&&?\\?&&?&&?\end{array}$$

Два рішення:

$$\begin{array}c&&5&&&&&&&5\\&2&&3&&&&&3&&2\\1&&1&&2&&&2&&1&&1\end{array}$$

Оскільки існує щонайменше два рішення, немає єдиного рішення.

Желе , 18 16 байт

FṀ‘ṗLSƝƬ€Ṗ€a@ċ⁼1

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

Монадійне посилання, яке приймає піраміду в зворотному порядку і повертає 1 для істинного і 0 для помилкового. Створює всі можливі піраміди з базою до максимального числа в піраміді та перевіряє, чи є одна унікальна відповідність для введення.

Дякуємо @Arnauld за те, що він зазначив, що це не вдалося [[1,0],[0]]; тепер виправлено.

Дякуємо @JonathanAlan за збереження 2 байтів!

Пояснення

F                | Flatten
 Ṁ               | Maximum
  ‘              | Increase by 1
   ṗ             | Cartesian power of this with:
    L            | - Length of input
        €        | For each:
       Ƭ         | - Repeat the following until no change
     SƝ          |   - Sum of neighbours
         Ṗ€      | Remove last element from each list
           a@    | Logical and input with each list
             ċ   | Count times input appears
              ⁼1 | Check if equal to 1

C # (Visual C # Interactive Compiler) , 303 227 байт

n=>{int i=n.Max(x=>x.Max()),j=n.Count,t=0,k,m=0,z;for(;t<Math.Pow(i,j);){k=t++;var s=n.Select(_=>(a:k%i+1,k/=i).a).ToList();if(n.All(x=>(z=0,b:x.All(o=>o==s[z++]|o<1),s=s.Skip(1).Select((a,b)=>a+s[b]).ToList()).b))m++;}m/=m-1;}

Викидає виняток, якщо є істинним, працює нормально, якщо помилково.

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

Мова Вольфрама (Mathematica) , 85 88 байт

Count[l=Length@#;NestList[2#~MovingMedian~2&,#,l-1]&/@Range@Max@#~Tuples~l,#/. 0->_]==1&

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

+3 фіксовано.

Сила грубої сили: для всіх баз зі значеннями подивіться, чи відповідає отримана піраміда заданій формі, і перевірте, чи загальна кількість збігів дорівнює 1. Візьме введення як список рівнів, базовий спочатку, із поданням пропущених чисел.1..(sum of all numbers)0

05AB1E , 25 байт

ZÌLsgãε©.Γü+}¨®š.S*˜O_}OΘ

Приймає шари піраміди вгору догори дном, основу до кінчика (тобто [[0,0,0,1],[0,2,0],[0,0],[10]]).

Крім того, здається, що десь у 05AB1E є помилка з .Γкартою. Він ©...®šповинен бути лише ...yšна 1 байт.

Спробуйте в Інтернеті або перевірте ще кілька тестових випадків .

Незначною альтернативою для рівних байтів ©.ΓüO}®šможе бути [Ðg#üO}\): Спробуйте його в Інтернеті.

Пояснення:

Z        # Get the flattened maximum of the (implicit) input (without popping)
 Ì       # Increase it by 2
  L      # Create a list in the range [1, max+2]
   sg    # Swap to get the input again, and get the length (amount of layers)
     ã   # Create a cartesian product of this list repeated that many times
ε        # Map each inner list to:
 ©       #  Store it in variable `®` (without popping)
  .Γ     #  Collect all results until the following doesn't change anymore:
    ü    #   Get the pairwise:
     +   #    Sums
   }®š   #  After we've collected all, prepend the original list `®`
 .S      #  Now compare this potential pyramid with the (implicit) input-pyramid
         #  (-1 if a<b; 0 if a==b; 1 if a>b)
   *     #  Multiply that with the (implicit) input-pyramid
    ˜O   #  Then take the flattened sum
      _  #  And check that this sum equals 0 (1 if truhy; 0 if falsey)
}O       # After the map, take the sum to get the amount of truthy values
  Θ      # And trutify it (== 1), since we must output distinct values instead of truthy/falsey
         # (after which the result is output implicitly)

Haskell, 106 байт

z=zipWith
a#b=a*b==a*a
f x=[1|t<-mapM(\_->[1..sum(sum<$>x)])x,all and$z(z(#))x$iterate(z(+)=<<tail)t]==[1]

Бере перевернуту піраміду, напр [[0,0,0,1],[0,2,0],[0,0],[10]].

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

Підхід грубої сили в Хаскеллі:

• створити всі можливі базові шари t( mapM(\_->[1..sum(sum<$>x)])x), де числа переходять від 1 до суми всіх чисел у вхідній піраміді
• створити піраміду з t( iterate(z(+)=<<tail)t)
• порівнюйте кожен елемент елементу з введенням ( z(z(#))x). Функція порівняння a # bповертається, Trueякщо обидва числа рівні або aдорівнюють нулю ( a*b==a*a).
• візьміть 1для кожної піраміди, яка відповідає, і порівняйте отриманий список з одиночним списком [1].