Un quadrato robusto (simile a un quadrato magico ) è una disposizione degli interi da 1 a N ² su una griglia N per N in modo tale che ogni sottogriglia 2 per 2 abbia la stessa somma.

Ad esempio, per N = 3 un quadrato robusto è

1 5 3
9 8 7
4 2 6

perché le quattro griglie secondarie 2 per 2

1 5
9 8

5 3
8 7

9 8
4 2

8 7
2 6

tutti sommano allo stesso importo, 23:

23 = 1 + 5 + 9 + 8 = 5 + 3 + 8 + 7 = 9 + 8 + 4 + 2 = 8 + 7 + 2 + 6

Ora ci sono quadrati robusti per valori più alti di N e persino versioni rettangolari ma il tuo unico compito in questa sfida è quello di produrre tutti i possibili quadrati 3 per 3 robusti. Esistono esattamente 376 quadrati 3 per 3 robusti, inclusi quelli che sono riflessi o rotazioni di altri, e non tutti hanno la stessa somma di 23.

Scrivi un programma o una funzione che non accetta input ma stampa o restituisce una stringa di tutti i 376 quadrati robusti in qualsiasi ordine, separati da righe vuote, con un massimo di due newline finali opzionali. Ogni quadrato dovrebbe essere composto da tre linee di tre cifre decimali diverse da zero separate da spazio.

Ecco un esempio di output valido:

1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

1 5 6
8 9 3
2 4 7

1 5 7
9 6 3
2 4 8

1 6 2
8 9 7
4 3 5

1 6 2
9 7 8
4 3 5

1 6 3
9 8 7
2 5 4

1 6 7
8 5 2
3 4 9

1 6 7
9 4 3
2 5 8

1 7 2
9 4 8
5 3 6

1 7 2
9 6 8
3 5 4

1 7 4
8 3 5
6 2 9

1 7 4
9 2 6
5 3 8

1 7 6
9 2 4
3 5 8

1 8 2
5 9 4
6 3 7

1 8 3
6 5 4
7 2 9

1 8 3
9 2 7
4 5 6

1 8 4
5 7 2
6 3 9

1 8 4
6 9 3
2 7 5

1 8 4
9 3 6
2 7 5

1 8 6
7 3 2
4 5 9

1 9 2
5 6 4
7 3 8

1 9 2
6 4 5
7 3 8

1 9 2
6 8 5
3 7 4

1 9 2
8 3 7
4 6 5

1 9 3
7 2 5
6 4 8

1 9 3
7 6 5
2 8 4

1 9 4
5 8 2
3 7 6

1 9 4
6 7 3
2 8 5

1 9 4
8 2 5
3 7 6

1 9 5
7 2 3
4 6 8

1 9 5
7 4 3
2 8 6

2 3 5
9 8 6
4 1 7

2 3 6
9 7 5
4 1 8

2 4 3
8 9 7
5 1 6

2 4 3
9 7 8
5 1 6

2 4 6
7 8 3
5 1 9

2 4 7
8 9 3
1 5 6

2 4 8
9 6 3
1 5 7

2 5 3
9 4 8
6 1 7

2 5 4
9 3 7
6 1 8

2 5 4
9 8 7
1 6 3

2 5 7
6 8 1
4 3 9

2 5 7
6 9 1
3 4 8

2 5 8
7 6 1
3 4 9

2 5 8
9 4 3
1 6 7

2 6 1
7 9 8
5 3 4

2 6 1
8 7 9
5 3 4

2 6 3
5 9 4
7 1 8

2 6 4
5 8 3
7 1 9

2 6 7
9 1 4
3 5 8

2 6 8
7 4 1
3 5 9

2 7 1
8 4 9
6 3 5

2 7 1
8 6 9
4 5 3

2 7 3
5 6 4
8 1 9

2 7 3
6 4 5
8 1 9

2 7 3
9 1 8
5 4 6

2 7 5
4 8 1
6 3 9

2 7 5
6 9 3
1 8 4

2 7 5
9 3 6
1 8 4

2 8 1
4 9 5
7 3 6

2 8 4
7 6 5
1 9 3

2 8 5
4 9 1
3 7 6

2 8 5
6 7 3
1 9 4

2 8 6
7 4 3
1 9 5

2 9 1
4 6 5
8 3 7

2 9 1
5 4 6
8 3 7

2 9 1
5 8 6
4 7 3

2 9 1
7 3 8
5 6 4

2 9 3
6 1 5
7 4 8

2 9 4
3 7 1
6 5 8

2 9 4
3 8 1
5 6 7

2 9 5
4 7 1
3 8 6

2 9 5
7 1 4
3 8 6

2 9 6
5 3 1
4 7 8

2 9 6
5 4 1
3 8 7

3 2 5
9 8 7
4 1 6

3 2 6
8 9 5
4 1 7

3 2 7
9 6 5
4 1 8

3 4 2
7 9 8
6 1 5

3 4 2
8 7 9
6 1 5

3 4 5
9 2 7
6 1 8

3 4 8
6 9 1
2 5 7

3 4 9
7 6 1
2 5 8

3 4 9
8 5 2
1 6 7

3 5 1
7 8 9
6 2 4

3 5 2
8 4 9
7 1 6

3 5 4
9 1 8
6 2 7

3 5 4
9 6 8
1 7 2

3 5 8
9 1 4
2 6 7

3 5 8
9 2 4
1 7 6

3 5 9
7 4 1
2 6 8

3 6 1
7 8 9
4 5 2

3 6 2
4 9 5
8 1 7

3 6 8
7 1 2
4 5 9

3 7 2
4 6 5
9 1 8

3 7 2
5 4 6
9 1 8

3 7 2
8 1 9
6 4 5

3 7 4
6 1 5
8 2 9

3 7 4
6 8 5
1 9 2

3 7 6
4 9 1
2 8 5

3 7 6
5 8 2
1 9 4

3 7 6
8 2 5
1 9 4

3 8 1
4 5 6
9 2 7

3 8 1
7 2 9
6 5 4

3 8 4
2 9 1
6 5 7

3 8 6
4 7 1
2 9 5

3 8 6
7 1 4
2 9 5

3 8 7
5 4 1
2 9 6

3 9 1
5 2 7
8 4 6

3 9 1
5 6 7
4 8 2

3 9 2
5 1 6
8 4 7

3 9 4
2 6 1
7 5 8

3 9 4
2 8 1
5 7 6

3 9 6
4 2 1
5 7 8

3 9 6
5 1 2
4 8 7

4 1 6
9 8 7
3 2 5

4 1 7
8 9 5
3 2 6

4 1 7
9 8 6
2 3 5

4 1 8
9 6 5
3 2 7

4 1 8
9 7 5
2 3 6

4 2 6
9 8 7
1 5 3

4 2 7
6 9 3
5 1 8

4 2 7
9 3 6
5 1 8

4 2 8
7 6 3
5 1 9

4 2 9
8 7 3
1 5 6

4 3 5
8 9 7
1 6 2

4 3 5
9 2 8
6 1 7

4 3 5
9 7 8
1 6 2

4 3 7
5 8 2
6 1 9

4 3 7
8 2 5
6 1 9

4 3 7
9 1 6
5 2 8

4 3 9
6 8 1
2 5 7

4 5 2
7 3 9
8 1 6

4 5 2
7 8 9
3 6 1

4 5 3
8 1 9
7 2 6

4 5 3
8 6 9
2 7 1

4 5 6
3 8 1
7 2 9

4 5 6
9 2 7
1 8 3

4 5 9
7 1 2
3 6 8

4 5 9
7 3 2
1 8 6

4 6 2
3 8 5
9 1 7

4 6 5
2 9 1
7 3 8

4 6 5
8 3 7
1 9 2

4 6 8
7 2 3
1 9 5

4 7 1
5 3 8
9 2 6

4 7 1
6 2 9
8 3 5

4 7 3
5 1 6
9 2 8

4 7 3
5 8 6
2 9 1

4 7 5
2 6 1
8 3 9

4 7 8
5 3 1
2 9 6

4 8 1
2 7 5
9 3 6

4 8 1
3 9 6
5 7 2

4 8 1
6 3 9
5 7 2

4 8 2
5 6 7
3 9 1

4 8 3
1 9 2
7 5 6

4 8 6
3 2 1
7 5 9

4 8 7
5 1 2
3 9 6

4 9 1
2 8 5
6 7 3

4 9 1
3 7 6
5 8 2

4 9 1
5 2 8
6 7 3

4 9 2
1 7 3
8 5 6

4 9 2
1 8 3
7 6 5

4 9 3
1 6 2
8 5 7

4 9 3
1 8 2
6 7 5

4 9 5
2 3 1
7 6 8

4 9 5
3 1 2
7 6 8

4 9 6
3 2 1
5 8 7

5 1 6
8 9 7
2 4 3

5 1 6
9 7 8
2 4 3

5 1 8
6 9 3
4 2 7

5 1 8
9 3 6
4 2 7

5 1 9
7 6 3
4 2 8

5 1 9
7 8 3
2 4 6

5 2 3
7 8 9
6 1 4

5 2 8
7 3 4
6 1 9

5 2 8
9 1 6
4 3 7

5 3 2
6 8 9
7 1 4

5 3 4
7 9 8
2 6 1

5 3 4
8 2 9
7 1 6

5 3 4
8 7 9
2 6 1

5 3 6
9 4 8
1 7 2

5 3 8
4 7 1
6 2 9

5 3 8
7 1 4
6 2 9

5 3 8
9 2 6
1 7 4

5 4 3
7 2 9
8 1 6

5 4 6
3 7 2
8 1 9

5 4 6
9 1 8
2 7 3

5 6 4
1 9 2
8 3 7

5 6 4
7 3 8
2 9 1

5 6 7
3 8 1
2 9 4

5 7 2
1 8 4
9 3 6

5 7 2
3 9 6
4 8 1

5 7 2
6 3 9
4 8 1

5 7 4
1 6 2
9 3 8

5 7 6
2 3 1
8 4 9

5 7 6
2 8 1
3 9 4

5 7 6
3 1 2
8 4 9

5 7 8
4 2 1
3 9 6

5 8 2
1 9 4
6 7 3

5 8 2
3 7 6
4 9 1

5 8 7
3 2 1
4 9 6

5 9 1
3 2 7
8 6 4

5 9 1
3 4 7
6 8 2

5 9 2
1 7 4
6 8 3

5 9 2
4 1 7
6 8 3

5 9 4
1 3 2
8 6 7

5 9 4
2 1 3
8 6 7

6 1 4
7 8 9
5 2 3

6 1 5
7 9 8
3 4 2

6 1 5
8 7 9
3 4 2

6 1 7
9 2 8
4 3 5

6 1 7
9 4 8
2 5 3

6 1 8
9 2 7
3 4 5

6 1 8
9 3 7
2 5 4

6 1 9
5 8 2
4 3 7

6 1 9
7 3 4
5 2 8

6 1 9
8 2 5
4 3 7

6 2 3
5 9 8
7 1 4

6 2 4
7 8 9
3 5 1

6 2 7
9 1 8
3 5 4

6 2 8
5 4 3
7 1 9

6 2 9
4 7 1
5 3 8

6 2 9
7 1 4
5 3 8

6 2 9
8 3 5
1 7 4

6 3 2
5 7 9
8 1 4

6 3 5
8 4 9
2 7 1

6 3 7
5 2 4
8 1 9

6 3 7
5 9 4
1 8 2

6 3 9
4 8 1
2 7 5

6 3 9
5 7 2
1 8 4

6 4 2
3 8 7
9 1 5

6 4 5
2 7 3
9 1 8

6 4 5
8 1 9
3 7 2

6 4 8
7 2 5
1 9 3

6 5 1
3 7 8
9 2 4

6 5 1
3 9 8
7 4 2

6 5 4
1 8 3
9 2 7

6 5 4
7 2 9
3 8 1

6 5 7
2 4 1
8 3 9

6 5 7
2 9 1
3 8 4

6 5 8
3 2 1
7 4 9

6 5 8
3 7 1
2 9 4

6 7 1
4 2 9
8 5 3

6 7 3
1 9 4
5 8 2

6 7 3
2 8 5
4 9 1

6 7 3
5 2 8
4 9 1

6 7 5
1 3 2
9 4 8

6 7 5
1 8 2
4 9 3

6 7 5
2 1 3
9 4 8

6 8 1
2 3 7
9 5 4

6 8 2
3 4 7
5 9 1

6 8 3
1 7 4
5 9 2

6 8 3
4 1 7
5 9 2

6 8 4
1 2 3
9 5 7

6 9 2
1 3 5
8 7 4

6 9 2
1 4 5
7 8 3

6 9 3
1 2 4
8 7 5

6 9 3
2 1 5
7 8 4

6 9 4
1 2 3
7 8 5

7 1 4
5 9 8
6 2 3

7 1 4
6 8 9
5 3 2

7 1 6
8 2 9
5 3 4

7 1 6
8 4 9
3 5 2

7 1 8
5 9 4
2 6 3

7 1 9
5 4 3
6 2 8

7 1 9
5 8 3
2 6 4

7 2 3
5 6 9
8 1 4

7 2 4
3 9 6
8 1 5

7 2 4
6 3 9
8 1 5

7 2 6
8 1 9
4 5 3

7 2 9
3 8 1
4 5 6

7 2 9
6 5 4
1 8 3

7 3 4
2 8 5
9 1 6

7 3 4
5 2 8
9 1 6

7 3 4
6 1 9
8 2 5

7 3 6
4 2 5
9 1 8

7 3 6
4 9 5
2 8 1

7 3 8
2 9 1
4 6 5

7 3 8
5 6 4
1 9 2

7 3 8
6 4 5
1 9 2

7 4 2
3 9 8
6 5 1

7 4 8
6 1 5
2 9 3

7 4 9
3 2 1
6 5 8

7 5 1
3 6 9
8 4 2

7 5 2
1 8 6
9 3 4

7 5 2
1 9 6
8 4 3

7 5 6
1 4 2
9 3 8

7 5 6
1 9 2
4 8 3

7 5 8
2 6 1
3 9 4

7 5 9
3 2 1
4 8 6

7 6 1
2 5 8
9 4 3

7 6 1
3 4 9
8 5 2

7 6 2
4 1 9
8 5 3

7 6 5
1 8 3
4 9 2

7 6 8
2 3 1
4 9 5

7 6 8
3 1 2
4 9 5

7 8 3
1 4 5
6 9 2

7 8 4
2 1 5
6 9 3

7 8 5
1 2 3
6 9 4

8 1 4
5 6 9
7 2 3

8 1 4
5 7 9
6 3 2

8 1 5
3 9 6
7 2 4

8 1 5
6 3 9
7 2 4

8 1 6
7 2 9
5 4 3

8 1 6
7 3 9
4 5 2

8 1 7
4 9 5
3 6 2

8 1 9
3 7 2
5 4 6

8 1 9
5 2 4
6 3 7

8 1 9
5 6 4
2 7 3

8 1 9
6 4 5
2 7 3

8 2 4
3 6 7
9 1 5

8 2 5
4 3 7
9 1 6

8 2 5
6 1 9
7 3 4

8 2 6
3 4 5
9 1 7

8 2 9
6 1 5
3 7 4

8 3 5
1 7 4
9 2 6

8 3 5
4 1 7
9 2 6

8 3 5
6 2 9
4 7 1

8 3 7
1 9 2
5 6 4

8 3 7
4 6 5
2 9 1

8 3 7
5 4 6
2 9 1

8 3 9
2 4 1
6 5 7

8 3 9
2 6 1
4 7 5

8 4 2
3 6 9
7 5 1

8 4 3
1 9 6
7 5 2

8 4 6
5 2 7
3 9 1

8 4 7
5 1 6
3 9 2

8 4 9
2 3 1
5 7 6

8 4 9
3 1 2
5 7 6

8 5 2
1 6 7
9 4 3

8 5 2
3 4 9
7 6 1

8 5 3
4 1 9
7 6 2

8 5 3
4 2 9
6 7 1

8 5 6
1 2 3
9 4 7

8 5 6
1 7 3
4 9 2

8 5 7
1 6 2
4 9 3

8 6 2
1 4 7
9 5 3

8 6 3
2 1 7
9 5 4

8 6 4
3 2 7
5 9 1

8 6 7
1 3 2
5 9 4

8 6 7
2 1 3
5 9 4

8 7 4
1 3 5
6 9 2

8 7 5
1 2 4
6 9 3

9 1 5
3 6 7
8 2 4

9 1 5
3 8 7
6 4 2

9 1 6
2 8 5
7 3 4

9 1 6
4 3 7
8 2 5

9 1 6
5 2 8
7 3 4

9 1 7
3 4 5
8 2 6

9 1 7
3 8 5
4 6 2

9 1 8
2 7 3
6 4 5

9 1 8
4 2 5
7 3 6

9 1 8
4 6 5
3 7 2

9 1 8
5 4 6
3 7 2

9 2 4
3 7 8
6 5 1

9 2 6
1 7 4
8 3 5

9 2 6
4 1 7
8 3 5

9 2 6
5 3 8
4 7 1

9 2 7
1 8 3
6 5 4

9 2 7
4 5 6
3 8 1

9 2 8
5 1 6
4 7 3

9 3 4
1 8 6
7 5 2

9 3 6
1 8 4
5 7 2

9 3 6
2 7 5
4 8 1

9 3 8
1 4 2
7 5 6

9 3 8
1 6 2
5 7 4

9 4 3
1 6 7
8 5 2

9 4 3
2 5 8
7 6 1

9 4 7
1 2 3
8 5 6

9 4 8
1 3 2
6 7 5

9 4 8
2 1 3
6 7 5

9 5 3
1 4 7
8 6 2

9 5 4
2 1 7
8 6 3

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4

Il tuo programma deve produrre gli stessi 376 quadrati robusti, ma non necessariamente in questo ordine. Non è necessario che l'output sia deterministico, ovvero è possibile emetterli in ordini diversi su diverse esecuzioni purché siano tutti presenti.

Vince il codice più breve in byte.

^{L'argomento dei quadrati robusti è nato da questo mio messaggio di chat che ha portato a una grande quantità di discussioni sulle loro proprietà e su come generarle. Puntelli a Peter Taylor , feersum e Sp3000 per continuare la discussione, e in particolare a El'endia Starman per aver redatto una corrispondente sequenza OEIS .}

Pyth, 38 34 33 32 byte

Vfq2l{sMX2.DR2.:T5b.pS9Vc3NjdH)k

5 byte salvati nella formattazione da Jakube

1 byte salvato passando alle sottostringhe di Peter Taylor di lunghezza cinque, rimuovendo l'approccio medio

Ci vuole circa un minuto e mezzo per correre sulla mia macchina.

Come funziona ad alto livello:

• Genera tutte le permutazioni ( .pS9)

• Lunghezza del modulo 5 sottostringhe ( .:T5)

• Rimuovi l'elemento centrale di ogni ( .DR2)

• Aggiungi una nuova riga all'elemento centrale, contrassegnandolo con una somma necessariamente diversa ( X2 ... b)

• Filtro per i quadrati in cui tutte queste somme sono uguali ( fq2l{)

• Formatta e stampa ( V ... Vc3NjdH)k)

CJam, 40 38 byte

A,1>e!3f/{2{2few:::+z}*:|,1=},Ma*Sf*N*

Grazie a @PeterTaylor per giocare a golf con 2 byte!

Questo termina immediatamente usando l'interprete Java. Funziona anche con l'interprete online, ma richiede un po 'di pazienza. Provalo online.

Prova

$ cjam sturdy-squares.cjam | head -n 8
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

$ cjam sturdy-squares.cjam | tail -n 8

9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4
$

Come funziona

A,1>     e# Push [1 ... 9].
e!       e# Push the array of all permutations of that array.
3f/      e# Split each into rows of length 3.
{        e# Filter; push the permutation, then:
  2{     e#   Do the following twice:
    2few e#     Split each row into overlapping splices of length 2.
         e#       [a b c] -> [[a b] [b c]]
    :::+ e#     Reduce each innermost vector to its sum.
         e#       [[a b] [b c]] -> [a+b b+c]
    z    e#     Transpose rows with columns.
  }*     e#   The result is [[s t] [u v]], the sums of all 2x2 squares.
  :|     e#   Perform set union of the pairs of sums.
  ,1=    e#   Check if the length of the result is 1 (unique sum).
},       e# Keep the array if the result was 1.
{        e# For each kept array:
  Sf*    e#   Join the elements of its rows, separating by spaces.
  ~M     e#   Dump the resulting strings and an empty string on the stack.
}%       e# Collect everything in an array.
N*       e# Join the strings, separating by linefeeds.

Python 3, 169 168 164 byte

Ho preso il programma che ho usato per indagare su questi quadrati / rettangoli robusti e ho giocato a golf fino in fondo. Golfato di 4 byte grazie a otakucode.

from itertools import*
r=range(1,10)
for p in permutations(r,6):
 x,y=p[0],p[5];q=p[:5]+(x+p[3]-p[2],y,y+p[1]-x,p[2]+y-x)
 if set(q)==set(r):print('%s %s %s\n'*3%q)

Spiegazione

Dato un quadrato robusto parzialmente riempito come questo,

a b c
d e ?
g ? ?

I restanti tre voci sono determinate univocamente, e sono a+d-c, a+b-ge c+g-a. Quindi ho generato tutte le permutazioni di 0..8 con sei elementi, ho calcolato il resto e quindi ho verificato se l'insieme di questo è uguale all'insieme di 0..8. Se lo è, stampo la griglia.

Per riferimento, ecco l'originale (con commenti e codice estraneo rimossi):

from itertools import permutations as P

n = 3
m = 3
permutes = P(range(m*n), m+n)

counter = 0
for p in permutes:
    grid = [p[:n]]
    for i in range(m-1):
        grid.append([p[n+i]]+[-1]*(n-1))
    grid[1][1] = p[-1]

    s = p[0]+p[1]+p[n]+p[-1]

    has = list(p)

    fail = 0
    for y in range(1,m):
        for x in range(1,n):
            if x == y == 1: continue

            r = s-(grid[y-1][x-1] + grid[y-1][x] + grid[y][x-1])

            if r not in has and 0 <= r < m*n:
                grid[y][x] = r
                has.append(r)
            else:
                fail = 1
                break

        if fail: break

    if not fail:
        counter += 1

print(counter)

Mathematica 147 166 155 149 byte

Questo genera le permutazioni di {1,2,3 ... 9} e seleziona i casi per i quali

(somma delle cifre nelle posizioni {1,2,4,5}) =

(somma delle cifre nelle posizioni {2,3,5,6}) =

(somma delle cifre nelle posizioni {4,5,7,8}) =

(somma delle cifre nelle posizioni {5,6,8,9})

f@s_:=Length@Tally[Tr@Extract[s,#]&/@Table[{{0},{1},{3},{4}}+k,{k,{1,2,4,5}}]]>1;
Row[Grid/@(#~Partition~3&/@Select[Permutations@Range@9,f@#&]),"\n"]

Output (uno sguardo parziale)

Length[%]

376

CJam ( 39 37 byte)

A,1>e!{5ew{2Mtz}2*::+)-!},3f/Ma*Sf*N*

Demo online (avviso: l'esecuzione del programma potrebbe richiedere più di un minuto, attivando il browser "Interrompi questo script?").

Funziona filtrando tutte le possibili griglie usando 5ewper mappare

[a b c d e f g h i]

per

[[a b c d e]
 [b c d e f]
 [c d e f g]
 [d e f g h]
 [e f g h i]]

e quindi scartando l'elemento centrale e l'elemento centrale di ogni altro elemento per ottenere

[[a b d e]
 [b c e f]
 [d e g h]
 [e f h i]]

quali sono i quattro quadrati.

Python 3.5, 135 byte

from itertools import*
for x in permutations(range(1,10)):eval((("=="+"+x[%s]"*3)*4)[2:]%(*"013125367578",))and print("%d %d %d\n"*3%x)

Controlla direttamente la somma di ogni quadrato, meno il centro. Molto probabilmente ancora golfabile dalla itertoolsregola empirica "non è necessaria".

python2 327 271 270 263 260 byte

z,v,s={},3,range(1,10)
while len(z)<376:
 for i in range(8):v=hash(`v`);s[i],s[v%9]=s[v%9],s[i]
 m=map(lambda i:sum(s[i:i+5])-s[i+2],[0,1,3,4]);T=tuple(s)
 if all(x==m[0] for x in m) and not T in z:
  z[T]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

------------

Questo non è ... non così breve ma non utilizza librerie. Questo permette a caso un quadrato, lo controlla per magia, lo stampa e lo registra per evitare duplicati. Dopo aver stampato 376 quadrati magici unici, si ferma.

Ho preso in prestito il generatore di numeri casuali pseudo dalla voce di Keith Randall per il golf chiamato " Costruisci un generatore di numeri casuali che superi i test di Diehard "

z,v={},3
def R(x,y):global v;v=hash(`v`);return v
while len(z)<376:
 s=sorted(range(1,10),cmp=R)
 m=[sum(q) for q in map(lambda p:s[p[0]:p[1]+1]+s[p[2]:p[3]+1], [[i,i+1,i+3,i+4] for i in [0,1,3,4]] )]
 if all(x==m[0] for x in m) and not tuple(s) in z.keys():
  z[tuple(s)]=1;print '%i %i %i\n'*3 % tuple(s[0:3]+s[3:6]+s[6:9])

De-golfed

# each magic square is an array of 9 numbers
#
#for example [1 9 3 7 2 5 6 4 8] 
#
#represents the following square
#
#1 9 3
#7 2 5
#6 4 8
#
# to generate a random square with each number represented only once,
# start with [1 2 3 4 5 6 7 8 9] and sort, but use a random comparison
# function so the sorting process becomes instead a random permutation.
# 
# to check each 2x2 subsquare for sums, look at the indexes into the
# array: [[0,1,3,4] = upper left,[1,2,4,5] = upper right, etc.
#
# to keep track of already-printed magic squares, use a dictionary    
# (associative array) where the 9-element array data is the key. 

from random import *
def magic(s):
 quads=[]
 for a,b,c,d in [[0,1,3,4],[1,2,4,5],[3,4,6,7],[4,5,7,8]]:
  quads+=[s[a:b+1]+s[c:d+1]]
 summ=[sum(q) for q in quads]
 same= all(x==summ[0] for x in summ)
 #print quads
 #print 'sum',summ
 #print 'same',same
 return same

magicsquares={}
while len(magicsquares.keys())<376:
        sq = sorted(range(1,10),key=lambda x:random())
        if magic(sq) and not magicsquares.has_key(tuple(sq)):
                magicsquares[tuple(sq)]=1
                print sq[0:3],'\n',sq[3:6],'\n',sq[6:9],'\n'

Ruby 133

a=[]
[*1..9].permutation{|x|[0,1,3,4].map{|i|x[i]+x[i+1]+x[i+3]+x[i+4]}.uniq.size<2&&a<<x.each_slice(3).map{|s|s*' '}*'
'}
$><<a*'

'

Approccio diretto alla forza bruta. Provalo qui .

J, 83 byte

([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:

Questa è una funzione che genera una stringa contenente i 376 quadrati robusti. Usa la forza bruta, genera tutte le permutazioni da 1 a 9, forma ciascuna in un array 3x3 e lo filtra controllando se le somme di ciascun subarray 2x2 sono uguali. Completa in mezzo secondo.

uso

   f =: ([:;@,(<LF),.~[:(<@(LF,~":)"1@#~([:*/2=/\[:,2 2+/@,;._3])"2)(3 3)($"1)1+!A.&i.])@9:
   $ f ''  NB. A function has to take something to be invoked,
           NB. but in this case it is not used by the function
   37 {. f ''  NB. Take the first 37 characters
1 5 3
9 8 7
4 2 6

1 5 6
8 7 3
4 2 9

   _38 {. f ''  NB. Take the last 38 characters
9 5 4
2 3 7
6 8 1

9 5 7
1 2 3
6 8 4


   NB. The output string ends with two newlines