Étant donné une pyramide d'addition $P$ , déterminez si elle peut être résolue. Une pyramide d'addition se compose de couches , chacune ayant un nombre inférieur à celui en dessous. La couche $i$ est symbolisée par $P_i$ . $P_1$ est la couche de base et $P_{i+1}$ est la couche au sommet de $P_i$ . Le $j$ ème nombre de $P_i$ est noté $P_{i,j}$ . $P_{i,1}$ est le nombre le plus à gauche de $P_i$ , et $P_{i,j+1}$ est le nombre à droite de$P_{i,j}$ . Vous pouvez visualiser$P_{i+1,j}$ résidant au-dessus de$P_{i,j}$ et$P_{i,j+1}$ au milieu, d'où le nom "pyramide d'addition".

• $\forall P_{i,j},P_{i,j}\in\mathbb N^*$ , c'est-à-dire que chaque nombre dans la pyramide est un entier positif non nul.
• $\forall i>1,P_{i,j}=P_{i-1,j}+P_{i-1,j+1}$ , c'est-à-dire que chaque nombre qui n'est pas sur la couche de base de la pyramide est la somme des deux nombres en dessous.
• Si $P_1$ a $n$ nombres, $P_i$ a $n-i+1$ nombres, donc $P_{i,n-i+1}$ est le nombre le plus à droite de $P_i$ . En termes plus simples, chaque couche a un numéro de moins que la couche en dessous.

Un puzzle pyramide d'addition $Q$ est une pyramide d'addition dont certains nombres ont été supprimés (remplacés par $?$ ). Sa solution est une pyramide d'addition $P$ , où $\forall Q_{i,j}\ne{?},P_{i,j}=Q_{i,j}$ , c'est-à-dire que les nombres qui étaient initialement présents dans le puzzle sont restés inchangés. Un tel casse-tête peut avoir plus d'une solution.

Votre tâche consiste, compte tenu d'un casse-tête à pyramide supplémentaire, à déterminer s'il a exactement une solution.

Contribution

Vous pouvez obtenir des informations sous l'une des formes suivantes, mais soyez cohérent:

• Tableau de couches.
• Tableau de couches, en forme de pyramide utilisant une valeur entière non positive cohérente comme séparateur entre les éléments (utilisé une seule fois à chaque fois) ainsi qu'un remplissage gauche et droit. Le séparateur et le rembourrage doivent être identiques.
• Tableau de calques avec un remplissage droit ou gauche cohérent valide (vous devez être cohérent et ne pas mélanger le remplissage droit et gauche dans ce cas).

Veuillez noter qu'une valeur cohérente qui n'est pas un entier strictement positif doit être utilisée pour représenter un nombre manquant; cette valeur ne peut pas être utilisée comme remplissage. De plus, vous pouvez prendre les couches concaténées (vous pouvez toujours les séparer), et l'ordre peut être de la base vers le haut ou du haut vers la base.

Production

L'une des deux valeurs distinctes cohérentes, où l'une représente la présence d'une solution unique et l'autre l'absence d'une solution ou la présence de plusieurs solutions.

Règles

• $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{?}$
• Ne fais pas ces choses .
• Il s'agit de code-golf , donc la réponse la plus courte l'emporte! Cependant, ne laissez pas cela vous décourager de publier une solution simplement parce que votre langue est "trop ​​verbeuse".

Cas de test

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

Exemples travaillés

Les cas de test sont travaillés ici.

Solution unique 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}$$

Les étapes 5-6 sont similaires à 4.

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

Nous avons donc ici notre solution unique.

Solution unique 2

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

Étape 1: Il n'y a pas d'approche évidente ici, alors essayons d'utiliser les valeurs minimales possibles.

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

Étapes 2 à 5: il semble que les valeurs minimales aboutissent à une solution, c'est donc la seule solution et donc unique.

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

Astuce: Il y a un théorème sur les puzzles de pyramides d'addition liés à ce puzzle que vous pouvez prouver si vous réfléchissez suffisamment.

Solution unique 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}$$

Il s'agit d'une solution évidemment unique.

Pas de solution 1

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

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

Pas de solution 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$

Solution non unique

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

Deux solutions:

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

Puisqu'il y a au moins deux solutions, il n'y a pas de solution unique.

Gelée , 18 16 octets

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

Essayez-le en ligne!

Un lien monadique qui prend la pyramide dans l'ordre inverse et renvoie 1 pour vrai et 0 pour faux. Génère toutes les pyramides possibles avec une base jusqu'au nombre maximum dans la pyramide et vérifie s'il existe une correspondance unique pour l'entrée.

Merci à @Arnauld d'avoir souligné que cela a échoué [[1,0],[0]]; maintenant corrigé.

Merci à @JonathanAlan pour avoir économisé 2 octets!

Explication

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 octets

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ève une exception si vrai, s'exécute normalement si faux.

Essayez-le en ligne!

Wolfram Language (Mathematica) , 85 88 octets

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

Essayez-le en ligne!

+3 fixe.

Force brute: pour toutes les bases avec des valeurs , voyez si la pyramide résultante correspond à la forme donnée, et vérifiez si le nombre total de correspondances est 1. Prend la saisie sous forme de liste de niveaux, base en premier, avec représentation des nombres manquants.1..(sum of all numbers)0

05AB1E , 25 octets

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

Prend les couches pyramidales à l'envers, de la base à la pointe (c.-à-d [[0,0,0,1],[0,2,0],[0,0],[10]].).

En outre, il semble y avoir un bogue quelque part dans 05AB1E avec à l' .Γintérieur d'une carte .. Le ©...®šdevrait juste être ...yšpour -1 octet ..

Essayez-le en ligne ou vérifiez quelques cas de test supplémentaires .

Une alternative mineure à octets égaux ©.ΓüO}®špourrait être [Ðg#üO}\): Essayez-la en ligne.

Explication:

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 octets

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]

Prend une pyramide à l'envers, par exemple [[0,0,0,1],[0,2,0],[0,0],[10]].

Essayez-le en ligne!

L'approche de la force brute à Haskell:

• créer toutes les couches de base possibles t( mapM(\_->[1..sum(sum<$>x)])x), où les nombres vont de 1 à la somme de tous les nombres dans la pyramide d'entrée
• créer une pyramide à partir de t( iterate(z(+)=<<tail)t)
• comparer chaque calque élément par élément avec l'entrée ( z(z(#))x). La fonction de comparaison a # brenvoie Truesi les deux nombres sont égaux ou asont nuls ( a*b==a*a).
• prendre une 1pour chaque pyramide qui correspond et comparer la liste résultante à la liste singleton [1].