Data un'aggiunta piramide $P$ , determinare se può essere risolto. Una piramide di addizione è composta da strati , ciascuno con un numero in meno di quello sotto di esso. Il livello $i$ è simbolizzato come $P_i$ . $P_1$ è lo strato base e $P_{i+1}$ è lo strato sopra $P_i$ . Il $j$ ° numero di $P_i$ è indicato come $P_{i,j}$ . $P_{i,1}$ è il numero più a sinistra di $P_i$ e $P_{i,j+1}$ è il numero a destra di$P_{i,j}$ . Puoi visualizzare$P_{i+1,j}$ residente in cima a$P_{i,j}$ e$P_{i,j+1}$ al centro, da cui il nome "addizionepiramide".

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$ , ovvero ogni numero nella piramide è un numero intero positivo diverso da zero.
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$ , ovvero ogni numero che non si trova sullo strato base della piramide è la somma dei due numeri sottostanti.
• Se $P_1$ ha $n$ numeri, $P_i$ ha $n-i+1$ numeri, quindi $P_{i,n-i+1}$ è il numero più a destra di $P_i$ . In termini più semplici, ogni livello ha un numero in meno rispetto al livello sottostante.

Un puzzle piramide addizionale $Q$ è una piramide addizionale con alcuni numeri rimossi (sostituiti con $?$ ). La sua soluzione è una piramide di aggiunta $P$ , dove $\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$ , ovvero i numeri originariamente presenti nel puzzle sono rimasti invariati. Un simile puzzle può avere più di una soluzione.

Il tuo compito è, dato un puzzle piramide addizionale, per determinare se ha esattamente una soluzione.

Ingresso

È possibile ottenere input in uno dei seguenti moduli, ma essere coerenti:

• Matrice di strati.
• Matrice di strati, a forma di piramide che utilizza un valore intero non positivo coerente come separatore tra gli elementi (usato solo una volta ogni volta) e imbottitura sinistra e destra. Il separatore e l'imbottitura devono essere uguali.
• Matrice di livelli con un'imbottitura destra o sinistra valida coerente (in questo caso è necessario essere coerenti e non mescolare l'imbottitura destra e sinistra).

Si noti che è necessario utilizzare un valore coerente che non sia un numero intero strettamente positivo per rappresentare un numero mancante; questo valore non può essere utilizzato come riempimento. Inoltre, puoi prendere i livelli concatenati (puoi ancora separarli) e l'ordinamento può essere dalla base alla cima o dall'alto alla base.

Produzione

Uno di due valori distinti coerenti, in cui uno rappresenta la presenza di una soluzione unica e l'altro l'assenza di una soluzione o la presenza di più di una soluzione.

Regole

• $Q_{i+1,j}=Q_{i,j}+Q_{i,j+1}$ sarà sempre vero se$Q_{i,j},Q_{i,j+1},Q_{i+1,j}\in\mathbb N^*$ , ovvero l'ingresso è garantito che non contenga un numero in cima ad altri due numeri che non è la loro somma se tutti e tre i numeri sono noti.
• $\exists Q_{i,j},Q_{i,j}\ne{?}$, cioè la piramide conterrà almeno un numero noto.
• Non fare queste cose .
• Questo è code-golf , quindi vince la risposta più breve! Tuttavia, non lasciarti scoraggiare dal pubblicare una soluzione solo perché la tua lingua è "troppo dettagliata".

Casi test

Un array con i livelli dall'alto verso il basso viene utilizzato per questi casi di test, con 0rappresentazione $?$.

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

Esempi lavorati

I casi di test sono lavorati qui.

Soluzione unica 1

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

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

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

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

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

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

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

$x+4=10\leftrightarrow x=6$

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

I passaggi 5-6 sono simili a 4.

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

Quindi qui abbiamo la nostra soluzione unica.

Soluzione unica 2

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

Passaggio 1: non esiste un approccio ovvio qui, quindi proviamo a utilizzare i valori minimi possibili.

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

Passaggi 2-5: sembra che i valori minimi risultino in una soluzione, quindi questa è l'unica soluzione ed è quindi unica.

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

Suggerimento: esiste un teorema sugli enigmi piramidali addizionali legati a questo enigma che puoi provare se pensi abbastanza bene.

Soluzione unica 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}$$

Questa è una soluzione ovviamente unica.

Nessuna soluzione 1

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

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

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

Soluzione non unica

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

Due soluzioni:

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

Dal momento che ci sono almeno due soluzioni, non esiste una soluzione unica.

Gelatina , 18 16 byte

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

Provalo online!

Un collegamento monadico che prende la piramide in ordine inverso e restituisce 1 per vero e 0 per falso. Genera tutte le possibili piramidi con una base fino al numero massimo nella piramide e controlla se esiste una corrispondenza univoca per l'input.

Grazie a @Arnauld per aver sottolineato che ciò non è riuscito [[1,0],[0]]; ora corretto.

Grazie a @JonathanAlan per aver salvato 2 byte!

Spiegazione

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 # (compilatore interattivo Visual C #) , 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;}

Genera un'eccezione se vero, funziona normalmente se falso.

Provalo online!

Wolfram Language (Mathematica) , 85 88 byte

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

Provalo online!

+3 fisso.

Forza bruta: per tutte le basi con valori , vedi se la piramide risultante corrisponde alla forma data e controlla se il numero totale di corrispondenze è 1. Prende l'input come un elenco di livelli, basando prima, con la rappresentazione di numeri mancanti.1..(sum of all numbers)0

05AB1E , 25 byte

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

Prende gli strati piramidali in ordine capovolto, dalla base alla punta (cioè [[0,0,0,1],[0,2,0],[0,0],[10]]).

Inoltre, sembra che ci sia un bug da qualche parte in 05AB1E con .Γall'interno di una mappa .. ©...®šDovrebbe essere solo ...yšper -1 byte ..

Provalo online o verifica alcuni altri casi di test .

Un'alternativa minore di uguali byte ©.ΓüO}®špotrebbe essere [Ðg#üO}\): Provalo online.

Spiegazione:

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 byte

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]

Presenta una piramide capovolta, ad es [[0,0,0,1],[0,2,0],[0,0],[10]].

Provalo online!

L'approccio della forza bruta in Haskell:

• crea tutti i possibili livelli base t( mapM(\_->[1..sum(sum<$>x)])x), dove i numeri vanno da 1 alla somma di tutti i numeri nella piramide di input
• crea una piramide da t( iterate(z(+)=<<tail)t)
• confrontare ogni livello elemento-saggio con l'input ( z(z(#))x). La funzione di confronto a # britorna Truese entrambi i numeri sono uguali o aè zero ( a*b==a*a).
• prendi a 1per ogni piramide che corrisponde e confronta l'elenco risultante con l'elenco singleton [1].