Un carré magique est une grille carrée n par n , remplie d'entiers positifs distincts dans la plage 1,2, ... n ^ 2 , de sorte que chaque cellule contient un entier différent et la somme des entiers de chaque ligne, la colonne et la diagonale sont égales.

Votre tâche consiste à prendre une matrice n par n composée de nombres positifs et d'un caractère d'espace réservé pour les cellules vides (je vais utiliser 0 , mais vous pouvez utiliser n'importe quel caractère non numérique ou type de données que vous aimez) et déterminer s'il s'agit possible de faire un carré magique en remplissant les nombres manquants

La matrice sera au moins 2 par 2 et au plus 10 par 10 . Le carré magique non trivial le plus petit possible est 3 par 3 . Les nombres dans la matrice d'entrée peuvent être supérieurs à n ^ 2 , et il est possible que toutes les cellules soient remplies.

Cas de test:

2   2
2   0
False

8   0   6
0   5   0
0   9   2
True

16    2    3   13
 5   11   10    8
 9    7    6   12
 4   14   15    1
True

10   0   1
 0   5   9
 3   7   5
False

99    40    74     8    15    51     0    67     0     1
 0    41    55    14     0    57    64     0    98     0
81    47    56    20    22    63    70    54     0    88
 0    28     0    21     0    69    71    60    85    19
 0    34     0     2     9    75    52    61     0    25
24    65    49     0    90    26    33    42    17    76
 0     0    30    89    91     0    39    48     0    82
 6    72    31    95     0    38    45    29     0    13
12    53     0    96    78     0     0     0    10    94
18    59    43    77     0     0    27    36     0   100
True

JavaScript (ES6), 270 268 octets

Prend la matrice comme un tableau 2D. Renvoie 0ou 1.

a=>(g=(x,y=0,w=a.length,p,R=a[y])=>[0,1,2,3].some(d=>a.some((r,y)=>(p=s)^(s=r.reduce((p,v,x)=>(o|=1<<(v=[v,(b=a[x])[y],b[x++],b[w-x]][d]),p+v),0))&&p),s=o=0)||o/2+1!=1<<w*w?R&&[...Array(w*w)].map((_,n)=>(p=R[x])==++n|!p&&(R[x]=n,g(z=(x+1)%w,y+!z),R[x]=p)):r=1)(r=0)&&r

Cas de test

C'est définitivement trop lent pour le dernier cas de test. :-(

let f =

a=>(g=(x,y=0,w=a.length,p,R=a[y])=>[0,1,2,3].some(d=>a.some((r,y)=>(p=s)^(s=r.reduce((p,v,x)=>(o|=1<<(v=[v,(b=a[x])[y],b[x++],b[w-x]][d]),p+v),0))&&p),s=o=0)||o/2+1!=1<<w*w?R&&[...Array(w*w)].map((_,n)=>(p=R[x])==++n|!p&&(R[x]=n,g(z=(x+1)%w,y+!z),R[x]=p)):r=1)(r=0)&&r

console.log(f([
  [ 2,  2 ],
  [ 2,  0 ]
]));

console.log(f([
  [ 8,  0,  6 ],
  [ 0,  5,  0 ],
  [ 0,  9,  2 ]
]));

console.log(f([
  [ 16,   2,   3,  13 ],
  [  5,  11,  10,   8 ],
  [  9,   7,   6,  12 ],
  [  4,  14,  15,   1 ]
]));

console.log(f([
  [ 10,  0,  1 ],
  [  0,  5,  9 ],
  [  3,  7,  5 ]
]));

05AB1E , 45 octets

Zsgn©>‹®L¹˜Kœ0ªε\¹˜0y.;¹gô©O®øO®Å\O®Å/O)˜Ë}à*

$0$$0$$n^2$$0$$0$

Cela aurait pu être de 4 octets de moins, mais il y a actuellement un bogue dans le buildin .;avec des listes 2D. :et .:fonctionne comme prévu, mais .;ne fait rien sur les listes 2D pour l'instant .. d'où le contournement ˜et l' ¹gôaplatissement de la matrice; utiliser .;sur la liste; et le transformer à nouveau en matrice.

Essayez-le en ligne ou vérifiez d'autres cas de test . (REMARQUE: le dernier cas de test de la description du défi n'est pas inclus, car il contient beaucoup trop de 0 ..)

Explication:

Z               # Get the maximum of the (implicit) input-matrix (implicitly flattened)
                # (and without popping the matrix)
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → 8
 s              # Swap to get the input-matrix again
  g             # Get its length (amount of rows)
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → 3
   n            # Square it
                #  i.e. 3 → 9
    ©           # Store it in the register (without popping)
     >‹         # Check if the maximum is <= this squared matrix-dimension
                #  i.e. 8 <= 9 → 1 (truthy)
®               # Push the squared matrix-dimension again
 L              # Create a list in the range [1, squared_matrix_dimension]
                #  i.e. 9 → [1,2,3,4,5,6,7,8,9]
  ¹             # Push the input-matrix
   ˜            # Flatten it
                #  i.e. [[8,0,6],[0,5,0],[0,0,2]] → [8,0,6,0,5,0,0,0,2]
    K           # Remove all these numbers from the ranged list
                #  i.e. [1,2,3,4,5,6,7,8,9] and [8,0,6,0,5,0,0,0,2] → [1,3,4,7,9]
œ               # Get all possible permutations of the remaining numbers
                # (this part is the main bottleneck of the program;
                #  the more 0s and too high numbers, the more permutations)
                #   i.e. [1,3,4,7,9] → [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1]]
 0ª             # Add an item 0 to the list (workaround for inputs without any 0s)
                #  i.e. [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1]] 
                #   → [[1,3,4,7,9],[1,3,4,9,7],...,[9,7,4,1,3],[9,7,4,3,1],"0"] 
   ε            # Map each permutation `y` to:
    \           #  Remove the implicit `y` which we don't need yet
    ¹˜          #  Push the flattened input again
      0         #  Push a 0
       y        #  Push permutation `y`
        .;      #  Replace all 0s with the numbers in the permutation one by one
                #   i.e. [8,0,6,0,5,0,0,0,2] and [1,3,4,7,9]
                #    → [8,1,6,3,5,4,7,9,2]
          ¹g    #  Push the input-dimension again
            ô   #  And split the flattened list into parts of that size,
                #  basically transforming it back into a matrix
                #   i.e. [8,1,6,3,5,4,7,9,2] and 3 → [[8,1,6],[3,5,4],[7,9,2]]
             ©  #  Save the matrix with all 0s filled in in the register (without popping)
    O           #  Take the sum of each row
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → [15,12,18]
    ®øO         #  Take the sum of each column
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → [18,15,12]
    ®Å\O        #  Take the sum of the top-left to bottom-right main diagonal
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → 15
    ®Å/O        #  Take the sum of the top-right to bottom-left main diagonal
                #   i.e. [[8,1,6],[3,5,4],[7,9,2]] → 18
    )           #  Wrap everything on the stack into a list
                #   → [[15,12,18],[18,15,12],15,18]
     ˜          #  Flatten it
                #   i.e. [[15,12,18],[18,15,12],15,18] → [15,12,18,18,15,12,15,18]
      Ë         #  Check if all values are equal
                #   i.e. [15,12,18,18,15,12,15,18] → 0 (falsey)
}               # After the map:
                #  → [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
 à              # Check if any are truthy by taking the maximum
                #  → 1 (truthy)
  *             # And multiply the two checks to verify both are truthy
                #  i.e. 1 and 1 → 1 (truthy)
                # (and output the result implicitly)

La partie ©O®øO®Å\O®Å/O)˜Ëest également utilisée dans ma réponse 05AB1E pour le défi Verify Magic Square , alors consultez cette réponse pour une explication plus approfondie de cette partie du code.