Bestimmen Sie anhand einer Additionspyramide , ob sie gelöst werden kann. Eine Additionspyramide besteht aus Schichten , von denen jede eine Nummer kleiner als die darunter liegende hat. Die Schicht wird als symbolisiert . ist die Basisschicht und ist die Schicht auf . Die te Zahl von wird als . ist die Zahl ganz links von und ist die Zahl rechts von . Sie können sich vorstellen, das sich auf$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}$und in der Mitte, daher der Name "addition Pyramide ".$P_{i,j+1}$

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$ , dh jede Zahl in der Pyramide ist eine positive ganze Zahl ungleich Null.
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$ , dh jede Zahl, die sich nicht auf der Basisschicht der Pyramide befindet, ist die Summe von die zwei Zahlen darunter.
• Wenn hat Zahlen, hat Zahlen daher ist die am weitesten rechts liegende Anzahl von . Einfacher ausgedrückt hat jede Ebene eine Zahl weniger als die darunter liegende Ebene.$P_1$$n$$P_i$$n-i+1$$P_{i,n-i+1}$$P_i$

Ein Additionspyramiden-Puzzle ist eine Additionspyramide, bei der einige Zahlen entfernt (durch Ersetzt ) wurden. Seine Lösung ist eine Additionspyramide , in der , die Zahlen, die ursprünglich im Puzzle vorhanden waren, haben wurde unverändert gelassen. Ein solches Puzzle kann mehr als eine Lösung haben.$Q$$?$$P$$\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$

Ihre Aufgabe ist es, anhand eines zusätzlichen Pyramidenrätsels festzustellen, ob es genau eine Lösung gibt.

Eingang

Sie können Eingaben in einer der folgenden Formen erhalten, aber konsistent sein:

• Array von Schichten.
• Anordnung von Ebenen, die wie eine Pyramide geformt sind und einen konsistenten nicht-positiven ganzzahligen Wert als Trennzeichen zwischen Elementen (jeweils nur einmal verwendet) sowie linker und rechter Abstand verwenden. Der Separator und die Polsterung müssen identisch sein.
• Array von Ebenen mit einem konsistenten gültigen rechten oder linken Abstand (Sie müssen konsistent sein und dürfen in diesem Fall nicht den rechten und den linken Abstand mischen).

Bitte beachten Sie, dass ein konsistenter Wert, der keine streng positive Ganzzahl ist, verwendet werden muss, um eine fehlende Zahl darzustellen. Dieser Wert kann nicht als Auffüllung verwendet werden. Sie können die Ebenen auch verkettet nehmen (Sie können sie immer noch trennen), und die Reihenfolge kann entweder von der Basis nach oben oder von oben nach unten erfolgen.

Ausgabe

Einer von zwei konsistenten unterschiedlichen Werten, wobei einer das Vorhandensein einer eindeutigen Lösung und der andere das Fehlen einer Lösung oder das Vorhandensein von mehr als einer Lösung darstellt.

Regeln

• $Q_{i+1,j}=Q_{i,j}+Q_{i,j+1}$ ist immer wahr, wenn , dh die Eingabe enthält garantiert keine Zahl über zwei anderen Zahlen, die nicht ihre Summe sind, wenn alle drei Zahlen bekannt sind.$Q_{i,j},Q_{i,j+1},Q_{i+1,j}\in\mathbb N^*$
• $\exists Q_{i,j},Q_{i,j}\ne{?}$ die Pyramide enthält mindestens eine bekannte Zahl.
• Tu diese Dinge nicht .
• Dies ist Code-Golf , also gewinnt die kürzeste Antwort! Lassen Sie sich jedoch nicht davon abhalten, eine Lösung zu veröffentlichen, nur weil Ihre Sprache "zu ausführlich" ist.

Testfälle

Eine Anordnung mit den Schichten von der Oberseite zu der Basis ist für diese Testfälle verwendet, mit 0repräsentierte$?$.

[[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

Arbeitsbeispiele

Die Testfälle werden hier bearbeitet.

Einzigartige Lösung 1

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

Schritt 1: $x+y=2\leftrightarrow x=y=1$ .

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

Schritt 2: $x=y=1\leftrightarrow x+y=2$ .

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

Schritt 3: $x=y=2\rightarrow x+y=4$ .

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

Schritt 4: $x+4=10\leftrightarrow x=6$ .

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

Die Schritte 5 bis 6 ähneln 4.

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

Hier haben wir also unsere einzigartige Lösung.

Einzigartige Lösung 2

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

Schritt 1: Hier gibt es keinen offensichtlichen Ansatz. Versuchen wir also, die minimal möglichen Werte zu verwenden.

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

Schritte 2-5: Es sieht so aus, als würden die Mindestwerte zu einer Lösung führen. Daher ist dies die einzige Lösung und daher eindeutig.

$$\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}$$

Hinweis: Es gibt einen Satz über Additionspyramiden-Rätsel im Zusammenhang mit diesem Rätsel, den Sie beweisen können, wenn Sie genau genug nachdenken.

Einzigartige Lösung 3

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

$x=y=1\rightarrow x+y=2$

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

Dies ist eine offensichtlich einzigartige Lösung.

Keine Lösung 1

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

$\min\mathbb N^*=1\rightarrow x,y\ge1\rightarrow x+y\ge2>1$

Keine Lösung 2

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

$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$

Nicht eindeutige Lösung

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

Zwei Lösungen:

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

Da es mindestens zwei Lösungen gibt, gibt es keine eindeutige Lösung.

Gelee , 18 16 Bytes

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

Probieren Sie es online aus!

Eine monadische Verbindung, die die Pyramide in umgekehrter Reihenfolge nimmt und 1 für wahr und 0 für falsch zurückgibt. Erzeugt alle möglichen Pyramiden mit einer Basis bis zur maximalen Anzahl in der Pyramide und prüft, ob es eine eindeutige Übereinstimmung für die Eingabe gibt.

Vielen Dank an @Arnauld für den Hinweis, dass dies fehlgeschlagen ist [[1,0],[0]]. jetzt korrigiert.

Vielen Dank an @JonathanAlan für das Speichern von 2 Bytes!

Erläuterung

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 Byte

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;}

Löst eine Ausnahme aus, wenn true, wird normal ausgeführt, wenn false.

Probieren Sie es online aus!

Wolfram Language (Mathematica) , 85 88 Bytes

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

Probieren Sie es online aus!

+3 behoben.

Brute Force: Überprüfen Sie für alle Basen mit Werten , ob die resultierende Pyramide mit der angegebenen Form übereinstimmt, und prüfen Sie, ob die Gesamtzahl der Übereinstimmungen 1 beträgt. Die Eingabe erfolgt als Liste der Ebenen, Basis zuerst, mit Darstellung fehlender Zahlen.1..(sum of all numbers)0

05AB1E , 25 Bytes

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

Nimmt die Pyramidenschichten auf den Kopf, von der Basis bis zur Spitze (dh [[0,0,0,1],[0,2,0],[0,0],[10]]).

Außerdem scheint es irgendwo in 05AB1E einen Fehler .Γinnerhalb einer Karte zu geben. Der ©...®šsollte nur ...yšfür -1 Byte sein.

Probieren Sie es online aus oder überprüfen Sie einige weitere Testfälle .

Eine kleinere Alternative für gleiche Bytes ©.ΓüO}®škönnte sein [Ðg#üO}\): Probieren Sie es online aus.

Erläuterung:

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 Bytes

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]

Nimmt eine umgedrehte Pyramide, z [[0,0,0,1],[0,2,0],[0,0],[10]].

Probieren Sie es online aus!

Der Brute-Force-Ansatz in Haskell:

• Erstellen Sie alle möglichen Basisebenen t( mapM(\_->[1..sum(sum<$>x)])x), wobei die Zahlen von 1 bis zur Summe aller Zahlen in der Eingabepyramide reichen
• Erstelle eine Pyramide aus t( iterate(z(+)=<<tail)t)
• Vergleichen Sie jede Ebene elementweise mit der Eingabe ( z(z(#))x). Die Vergleichsfunktion gibt a # bzurück, Truewenn beide Zahlen gleich oder aNull sind ( a*b==a*a).
• Nehmen Sie 1für jede passende Pyramide ein und vergleichen Sie die resultierende Liste mit der Singleton-Liste [1].