Dans le triangle de Pascal, chaque nombre est la somme des deux nombres directement au-dessus, en traitant les espaces vides comme zéro:

En faisant tourner le triangle, nous pouvons découper des matrices carrées de tailles et de rotations différentes que j'appellerai des matrices de Pascal . Notez que ces matrices doivent toujours contenir le top . Voici quelques exemples:$1$

1  1  1  1
1  2  3  4
1  3  6 10
1  4 10 20

6  3  1
3  2  1
1  1  1

1  5 15 35 70
1  4 10 20 35
1  3  6 10 15
1  2  3  4  5
1  1  1  1  1

1

1  1
2  1

La tâche

Étant donné une matrice carrée contenant des nombres positifs dans n'importe quel format raisonnable, décidez s'il s'agit d'une matrice de Pascal .

Décider signifie renvoyer des valeurs véridiques ou fausses selon que l'entrée est une matrice de Pascal , ou fixer deux valeurs constantes et renvoyer l'une pour les vraies entrées et l'autre pour les fausses entrées.

Il s'agit de code-golf , essayez donc d'utiliser le moins d'octets possible dans la langue de votre choix. Le code le plus court dans chaque langue gagne, donc je n'accepterai pas de réponse.

Cas de test

Vrai

[[1, 1, 1, 1], [1, 2, 3, 4], [1, 3, 6, 10], [1, 4, 10, 20]]
[[6, 3, 1], [3, 2, 1], [1, 1, 1]]
[[1, 5, 15, 35, 70], [1, 4, 10, 20, 35], [1, 3, 6, 10, 15], [1, 2, 3, 4, 5], [1, 1, 1, 1, 1]]
[[1]]
[[1, 1], [2, 1]]

Faux

[[2]]
[[1, 2], [2, 1]]
[[1, 1], [3, 1]]
[[1, 1, 1, 1], [1, 2, 3, 4], [1, 4, 6, 10], [1, 4, 10, 20]]
[[6, 3, 1], [1, 1, 1], [3, 2, 1]]
[[2, 2, 2, 2], [2, 4, 6, 8], [2, 6, 12, 20], [2, 8, 20, 40]]
[[40, 20, 8, 2], [20, 12, 6, 2], [8, 6, 4, 2], [2, 2, 2, 2]] 
[[1, 5, 15, 34, 70], [1, 4, 10, 20, 34], [1, 3, 6, 10, 15], [1, 2, 3, 4, 5], [1, 1, 1, 1, 1]]

Brachylog , 28 24 23 octets

Cela semble assez long, mais le voici quand même

• -4 octets grâce à DLosc en compressant les flips optionnels
• -1 octets grâce à DLosc à nouveau en faisant les sommes partielles en 1 fois

{|↔}\↰₁{k{a₀ᶠ+ᵐ}ᵐ⊆?h=₁}

Explication

{|↔}\↰₁{k{a₀ᶠ+ᵐ}ᵐ⊆?h=₁}       # Tests if this is a pascal matrix:
{|↔}\↰₁                       #     By trying to get a rows of 1's on top
{|↔}                          #       Through optionally mirroring vertically
     \                        #       Transposing
      ↰₁                      #       Through optionally mirroring vertically

       {k{a₀ᶠ+ᵐ}ᵐ⊆?h=₁}       #     and checking the following
                  ?h=₁        #        first row is a rows of 1's
        k{     }ᵐ             #        and for each row except the last
          a₀ᶠ+ᵐ               #          calculate the partial sum by
          a₀ᶠ                 #             take all prefixes of the input
             +ᵐ               #             and sum each
               ⊆?             #        => as a list is a subsequence of the rotated input

Essayez-le en ligne!

JavaScript (ES6), 114 octets

m=>[m,m,m=m.map(r=>[...r].reverse()),m].some(m=>m.reverse(p=[1]).every(r=>p=!r.some((v,x)=>v-~~p[x]-~~r[x-1])&&r))

Essayez-le en ligne!

MATL , 17 octets

4:"Gas2YLG@X!X=va

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Sorties 1pour les matrices Pascal, 0sinon.

Explication

4:      % Push [1 2 3 4]
"       % For each
  G     %   Push input: N×N
  a     %   1×N vector containing 1 for matrix columns that have at least a nonzero
        %   entry, and 0 otherwise. So it gives a vector containing 1 in all entries
  s     %   Sum. Gives N
  2YL   %   Pascal matrix of that size
  G     %   Push input
  @     %   Push current iteration index
  X!    %   Rotate the matrix that many times in steps of 90 degress
  X=    %   Are they equal?
  v     %   Concatenate with previous accumulated result
  a     %   Gives 1 if at least one entry of the vector is nonzero
        % End (implicit). Display (implicit)

R , 104 octets

function(m,R=row(m)-1,y=nrow(m):1,Z=choose(R+t(R),R))any(sapply(list(Z,Z[,y],Z[y,y],Z[y,]),identical,m))

Essayez-le en ligne!

Méchant...

Crée une matrice canonique de Pascal Zavec des dimensions égales à celle de m, puis teste si la matrice d'entrée mest identicalà anydes rotations de Z.

Fusain , 41 octets

Ｆ‹¹⌈§θ⁰≔⮌θθＦ‹¹⌈Ｅθ§ι⁰≦⮌θ⌊⭆θ⭆ι⁼λ∨¬κΣ…§θ⊖κ⊕μ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

Ｆ‹¹⌈§θ⁰

Si le maximum de sa première ligne est supérieur à 1,

≔⮌θθ

puis retournez le tableau d'entrée.

Ｆ‹¹⌈Ｅθ§ι⁰

Si le maximum de sa première colonne est supérieur à 1,

≦⮌θ

puis mettez en miroir le tableau d'entrée.

⌊⭆θ⭆ι

Faites une boucle sur les éléments du tableau d'entrée et imprimez le résultat minimum (c'est-à-dire le logique Et de tous les résultats),

⁼λ∨¬κΣ…§θ⊖κ⊕μ

comparer chaque valeur à 1 si elle se trouve sur la première ligne, sinon la somme de la ligne ci-dessus jusqu'à et y compris la cellule ci-dessus.

Python 2 , 129 octets

f=lambda M,i=4:i and(set(M[0])=={1}and all(a+b==c for x,y in zip(M,M[1:])for a,b,c in zip(x[1:],y,y[1:]))or f(zip(*M[::-1]),i-1))

Essayez-le en ligne!

Renvoie Trueif Mest une matrice de Pascal, else 0.

05AB1E , 29 octets

¬P≠iR}DøнP≠ií}¬PΘsü)ε`sηOQ}P*

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

¬P≠i }        # If the product of the first row of the (implicit) input-matrix is NOT 1:
    R         #  Reverse the order of the rows
D             # Duplicate the resulting matrix
 øнP≠i }      # If the product of the first column is NOT 1:
      í       #  Reverse each row individually
¬PΘ           # Check if the product of the first row is exactly 1
           *  # AND
          P   # And check if everything after the following map is truthy:
sü)ε     }    #  Map over each pair of rows:
    `sη       #   Get the prefixes of the first row
       O      #   Sum each prefix
        Q     #   And check if it's equal to the second row
              # (and output the result implicitly)

Kotlin , 269 octets

{m:List<List<Int>>->val n=m.size
var r=0
var c=0
fun f()=if(m[0][0]!=1)m[n-r-1][n-c-1]
else if(m[n-1][0]!=1)m[r][n-c-1]
else if(m[0][n-1]!=1)m[n-r-1][c]
else m[r][c]
var g=0<1
for(l in 0..n*2-2){r=l
c=0
var v=1
do{if(r<n&&c<n)g=f()==v&&g
v=v*(l-c)/++c}while(--r>=0)}
g}

Essayez-le en ligne!

Julia 0,7 , 78 octets

m->any(i->(n=rotr90(m,i))[1]<2&&all(cumsum(n)'[1:end-1,:]-n[2:end,:].==0),0:3)

Essayez-le en ligne!

Java (JDK) , 234 octets

m->{int l=m.length,L=l-1,p=1,s=0,S=0,e=l,E=l,d=1,D=1,i,j;if(m[0][0]>1|m[0][L]>1){s=L;e=d=-1;}if(m[0][0]>1|m[L][0]>1){S=L;E=D=-1;}for(i=s;i!=e;i+=d)for(j=S;j!=E;j+=D)p=(i==s|j==S?m[i][j]<2:m[i][j]==m[i-d][j]+m[i][j-D])?p:0;return p>0;}

Essayez-le en ligne!

Crédits

• -1 octet merci à Kevin Cruijssen .

Gelée , 22 octets

Ż€Iṫ2⁼ṖaFḢ=1Ʋ
,Ṛ;U$Ç€Ẹ

Essayez-le en ligne!

Explication

Lien d'aide, vérifie si cette rotation de matrice est valide

Ż€            | prepend each row with zero
  I           | find differences within rows
   ṫ2         | drop the first row
     ⁼Ṗ       | compare to the original matrix
              |   with the last row removed
       a      | logical and
        FḢ=1Ʋ | top left cell is 1

Lien principal

,Ṛ            | copy the matrix and reverse the rows
  ;U$         | append a copy of both of these
              |   with the columns reversed
     ǀ       | run each version of the matrix
              |   through the helper link
       Ẹ      | check if any are valid