Dada una pirámide de adición $P$ , determine si se puede resolver. Una pirámide de suma consta de capas , cada una con un número menor que el que está debajo. La capa $i$ se simboliza como $P_i$ . $P_1$ es la capa base, y $P_{i+1}$ es la capa sobre $P_i$ . El número $j$ de $P_i$ se denota como $P_{i,j}$ . $P_{i,1}$ es el número más a la izquierda de $P_i$ , y $P_{i,j+1}$ es el número a la derecha de$P_{i,j}$ . Puede visualizar$P_{i+1,j}$ reside en la parte superior de$P_{i,j}$ y$P_{i,j+1}$ en el medio, de ahí el nombre de "pirámide desuma".

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$ , es decir, cada número en la pirámide es un entero positivo distinto de cero.
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$ , es decir, cada número que no está en la capa base de la pirámide es la suma de los dos números debajo de él.
• Si $P_1$ tiene $n$ números, $P_i$ tiene $n-i+1$ números, por lo tanto $P_{i,n-i+1}$ es el número más a la derecha de $P_i$ . En términos más simples, cada capa tiene un número menor que la capa debajo de ella.

Un rompecabezas de pirámide de suma $Q$ es una pirámide de suma con algunos números eliminados (¿reemplazados por $?$ ). Su solución es una pirámide de suma $P$ , donde $\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$ , es decir, los números que originalmente estaban presentes en el rompecabezas no se han modificado. Tal rompecabezas puede tener más de una solución.

Su trabajo es, dado un rompecabezas piramidal adicional, determinar si tiene exactamente una solución.

Entrada

Puede obtener información en cualquiera de las siguientes formas, pero sea coherente:

• Matriz de capas.
• Matriz de capas, con forma de pirámide que utiliza un valor entero no positivo constante como separador entre elementos (se usa solo una vez cada vez), así como el relleno izquierdo y derecho. El separador y el relleno deben ser iguales.
• Matriz de capas con un relleno correcto derecho o izquierdo consistente (debe ser consistente y no mezclar el relleno derecho e izquierdo en este caso).

Tenga en cuenta que un valor consistente que no sea un entero estrictamente positivo debe usarse para representar un número faltante; Este valor no se puede utilizar como relleno. Además, puede tomar las capas concatenadas (aún puede separarlas), y el orden puede ser desde la base hasta la parte superior o desde la parte superior hacia la base.

Salida

Uno de dos valores distintos consistentes, donde uno representa la presencia de una solución única y el otro la ausencia de una solución o la presencia de más de una solución.

Reglas

• $Q_{i+1,j}=Q_{i,j}+Q_{i,j+1}$ siempre será cierto si$Q_{i,j},Q_{i,j+1},Q_{i+1,j}\in\mathbb N^*$ , es decir, la entrada se garantiza que no contendrá un número encima de otros dos números que no sea su suma si se conocen los tres números.
• $\exists Q_{i,j},Q_{i,j}\ne{?}$, es decir, la pirámide contendrá al menos un número conocido.
• No hagas estas cosas .
• Este es el código de golf , por lo que gana la respuesta más corta. Sin embargo, no permita que eso lo desanime de publicar una solución solo porque su idioma es "demasiado detallado".

Casos de prueba

Una matriz con las capas desde la parte superior a la base se utiliza para estos casos de prueba, con 0representación $?$.

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

Ejemplos trabajados

Los casos de prueba se trabajan aquí.

Solución única 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}$$

Los pasos 5-6 son similares a 4.

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

Entonces aquí tenemos nuestra solución única.

Solución única 2

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

Paso 1: Aquí no hay un enfoque obvio, así que intentemos usar los valores mínimos posibles.

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

Pasos 2-5: Parece que los valores mínimos dan como resultado una solución, por lo tanto, esta es la única solución y, por lo tanto, es única.

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

Sugerencia: Hay un teorema sobre los rompecabezas de pirámides de suma relacionados con este rompecabezas que puedes probar si piensas lo suficiente.

Solución única 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}$$

Esta es obviamente una solución única.

Sin solución 1

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

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

Sin solución 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$

Solución no única

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

Dos soluciones:

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

Como hay al menos dos soluciones, no hay una solución única.

Jalea , 18 16 bytes

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

Pruébalo en línea!

Un enlace monádico que toma la pirámide en orden inverso y devuelve 1 para verdadero y 0 para falso. Genera todas las pirámides posibles con una base hasta el número máximo en la pirámide y comprueba si hay una coincidencia única para la entrada.

Gracias a @Arnauld por señalar que esto falló [[1,0],[0]]; Ahora corregido.

¡Gracias a @JonathanAlan por guardar 2 bytes!

Explicación

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 # (compilador interactivo de Visual C #) , 303 227 bytes

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

Lanza una excepción si es verdadero, se ejecuta normalmente si es falso.

Pruébalo en línea!

Wolfram Language (Mathematica) , 85 88 bytes

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

Pruébalo en línea!

+3 fijo.

Fuerza bruta: para todas las bases con valores , vea si la pirámide resultante coincide con la forma dada, y verifique si el número total de coincidencias es 1. Toma la entrada como una lista de niveles, base primero, con la representación de números faltantes.1..(sum of all numbers)0

05AB1E , 25 bytes

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

Toma las capas de la pirámide en orden invertido, de la base a la punta (es decir [[0,0,0,1],[0,2,0],[0,0],[10]]).

Además, parece haber un error en algún lugar de 05AB1E .Γdentro de un mapa. ©...®šDebería ser ...yšde -1 byte.

Pruébelo en línea o verifique algunos casos de prueba más .

Una alternativa menor para bytes iguales ©.ΓüO}®špodría ser [Ðg#üO}\): Pruébelo en línea.

Explicación:

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]

Toma una pirámide invertida, por ejemplo [[0,0,0,1],[0,2,0],[0,0],[10]].

Pruébalo en línea!

El enfoque de la fuerza bruta en Haskell:

• crear todas las capas base posibles t( mapM(\_->[1..sum(sum<$>x)])x), donde los números van del 1 a la suma de todos los números en la pirámide de entrada
• crear una pirámide a partir de t( iterate(z(+)=<<tail)t)
• compare cada capa por elementos con la entrada ( z(z(#))x). La función de comparación a # bdevuelve Truesi ambos números son iguales o aes cero ( a*b==a*a).
• tome una 1para cada pirámide que coincida y compare la lista resultante con la lista singleton [1].