Le défi d'aujourd'hui est simple: sans prendre aucune entrée, sortir n'importe quelle carte sudoku valide.

Dans le cas où vous n'êtes pas familier avec le sudoku, Wikipedia décrit à quoi devrait ressembler un tableau valide :

L'objectif est de remplir une grille 9 × 9 avec des chiffres afin que chaque colonne, chaque ligne et chacune des neuf sous-grilles 3 × 3 qui composent la grille (également appelées "boîtes", "blocs" ou "régions") contiennent tous les chiffres de 1 à 9.

Maintenant, voici la chose ... Il existe 6 670 903 752 021 022 936 960 différents conseils sudoku valides . Certains d'entre eux peuvent être très difficiles à compresser et à produire en moins d'octets. D'autres peuvent être plus faciles. Une partie de ce défi consiste à déterminer quelles cartes seront les plus compressibles et pourraient être sorties dans le moins d'octets.

Votre soumission ne doit pas nécessairement produire la même carte à chaque fois. Mais si plusieurs sorties sont possibles, vous devrez prouver que chaque sortie possible est une carte valide.

Vous pouvez utiliser ce script (grâce à Magic Octopus Urn) ou l' une de ces réponses pour vérifier si une grille particulière est une solution valide. Il produira un [1]pour une carte valide et tout le reste pour une carte non valide.

Je ne suis pas trop pointilleux sur le format dans lequel vous produisez votre réponse, tant qu'il est clairement bidimensionnel. Par exemple, vous pouvez générer une matrice 9x9, neuf matrices 3x3, une chaîne, un tableau de chaînes, un tableau d'entiers à 9 chiffres ou neuf nombres à 9 chiffres avec un séparateur. La sortie de 81 chiffres dans 1 dimension ne serait pas autorisée. Si vous souhaitez connaître un format de sortie particulier, n'hésitez pas à me le demander dans les commentaires.

Comme d'habitude, il s'agit de code-golf , alors écrivez la réponse la plus courte que vous pouvez trouver dans la ou les langues de votre choix!

Pyth, 22 14 12 10 octets

.<LS9%D3 9

Enregistré 2 octets grâce à M. Xcoder.

Essayez-le ici

.<LS9%D3 9
     %D3 9     Order the range [0, ..., 8] mod 3.
  >            For each, ...
.< S9          ... Rotate the list [1, ..., 9] that many times.

Python 2 , 47 octets

l=range(1,10)
for x in l:print(l*9)[x*8/3:][:9]

Essayez-le en ligne!

T-SQL, 96 89 octets

Trouvé un plus court que la sortie triviale!

SELECT SUBSTRING('12345678912345678',0+value,9)FROM STRING_SPLIT('1,4,7,2,5,8,3,6,9',',')

Extrait des chaînes de 9 caractères commençant à différents points, comme défini par la table en mémoire créée par STRING_SPLIT(qui est prise en charge sur SQL 2016 et versions ultérieures). Le 0+valueétait le plus court chemin que je pouvais faire un casting implicite entier.

Sortie triviale d'origine (96 octets):

PRINT'726493815
315728946
489651237
852147693
673985124
941362758
194836572
567214389
238579461'

Gelée , 7 octets

9Rṙ%3$Þ

Essayez-le en ligne!

Et un peu de cela ...
-1 grâce à Jonathan Allan (la réflexion?)

Python 2 , 53 octets

r=range(9)
for i in r:print[1+(j*10/3+i)%9for j in r]

Essayez-le en ligne!

Alternatives:

Python 2 , 53 octets

i=0;exec"print[1+(i/3+j)%9for j in range(9)];i-=8;"*9

Essayez-le en ligne!

Python 2 , 54 octets

for i in range(81):print(i/9*10/3+i)%9+1,'\n'*(i%9>7),

i=0;exec"print[1+(i/3+j)%9for j in range(9)];i+=10;"*9

r=range(9);print[[1+(i*10/3+j)%9for j in r]for i in r]

Python 3 , 58 55 octets

l=*range(10),
for i in b"	":print(l[i:]+l[1:i])

Essayez-le en ligne!

• -3 octets grâce à Jo King,

Les éléments de la chaîne d'octets finissent par donner les nombres [1, 4, 7, 2, 5, 8, 3, 6, 9]qui sont utilisés pour permuter les rotations de [0..9]. Le 0est supprimé l[1:i]et il n'est pas nécessaire qu'un octet nul prenne deux caractères ( \0) pour représenter dans un objet octets.

55 octets

_,*l=range(10)
for i in b"	":print(l[i:]+l[:i])

Gelée , 9 8 octets

9Rṙ`s3ZẎ

Essayez-le en ligne!

9Rṙ`s3ZẎ
9R         Range(9) -> [1,2,3,4,5,6,7,8,9]
   `       Use the same argument twice for the dyad:
  ṙ        Rotate [1..9] each of [1..9] times.
           This gives all cyclic rotations of the list [1..9]
    s3     Split into three lists.
      Z    Zip. This puts the first row of each list of three in it's own list, 
           as well as the the second and third.
       Ẏ   Dump into a single list of nine arrays.

Lot, 84 octets

@set s=123456789
@for %%a in (0 3 6 1 4 7 2 5 8)do @call echo %%s:~%%a%%%%s:~,%%a%%

Utilise la sortie de @ Mnemonic. callest utilisé pour interpoler la variable dans l'opération de découpage (normalement, il n'accepte que les constantes numériques).

JavaScript (Node.js) , 47 octets

Sortie sous forme de tableau de lignes.

_=>[...w="147258369"].map(x=>(w+w).substr(x,9))

Essayez-le en ligne!

Génère ceci:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6 , 40 32 27 octets

-5 octets grâce à nwellnhof

{[^9+1].rotate($+=3.3)xx 9}

Essayez-le en ligne!

Bloc de code anonyme qui renvoie une matrice 9x9. Mappe chaque ligne sur une rotation différente de la plage de 1 à 9.

J , 18 octets

>:(,&|:|."{,)i.3 3

Essayez-le en ligne!

Sortie

1 2 3 4 5 6 7 8 9
4 5 6 7 8 9 1 2 3
7 8 9 1 2 3 4 5 6
2 3 4 5 6 7 8 9 1
5 6 7 8 9 1 2 3 4
8 9 1 2 3 4 5 6 7
3 4 5 6 7 8 9 1 2
6 7 8 9 1 2 3 4 5
9 1 2 3 4 5 6 7 8

Comment ça marche

>:(,&|:|."{,)i.3 3
             i.3 3  The 2D array X = [0 1 2;3 4 5;6 7 8]
   ,&|:|."{,        3-verb train:
   ,&|:               Transpose and flatten X to get Y = [0 3 6 1 4 7 2 5 8]
           ,          Flatten X to get Z = [0 1 2 3 4 5 6 7 8]
       |."{           Get 2D array whose rows are Z rotated Y times
>:                  Increment

Version fantaisie, 23 octets

|.&(>:i.3 3)&.>|:{;~i.3

Essayez-le en ligne!

Sortie:

┌─────┬─────┬─────┐
│1 2 3│4 5 6│7 8 9│
│4 5 6│7 8 9│1 2 3│
│7 8 9│1 2 3│4 5 6│
├─────┼─────┼─────┤
│2 3 1│5 6 4│8 9 7│
│5 6 4│8 9 7│2 3 1│
│8 9 7│2 3 1│5 6 4│
├─────┼─────┼─────┤
│3 1 2│6 4 5│9 7 8│
│6 4 5│9 7 8│3 1 2│
│9 7 8│3 1 2│6 4 5│
└─────┴─────┴─────┘

Comment ça marche

|.&(>:i.3 3)&.>|:{;~i.3
                    i.3  Array [0 1 2]
                 {;~     Get 2D array of boxed pairs (0 0) to (2 2)
               |:        Transpose
|.&(>:i.3 3)&.>          Change each pair to a Sudoku box:
            &.>            Unbox
    >:i.3 3                2D array X = [1 2 3;4 5 6;7 8 9]
|.&                        Rotate this 2D array over both axes
                             e.g. 1 2|.X gives [6 4 5;9 7 8;3 1 2]
            &.>            Box again so the result looks like the above

05AB1E , 14 12 octets

8ÝΣ3%}ε9Ls._

-2 octets en créant un port de @Mnemonic réponse Pyth s » .

Essayez-le en ligne. (Le pied de page est ajouté pour l'imprimer. Le résultat réel est une matrice 9x9; n'hésitez pas à retirer le pied de page pour voir.)

Explication:

8Ý              # List in the range [0, 8]
  Σ  }          # Sort the integers `i` by
   3%           #  `i` modulo-3
      ε         # Map each value to:
       9L       #  List in the range [1, 9]
         s._    #  Rotated towards the left the value amount of times

Solution originale de 14 octets :

9Lε9LN3*N3÷+._

Essayez-le en ligne. (Le pied de page est ajouté pour l'imprimer. Le résultat réel est une matrice 9x9; n'hésitez pas à retirer le pied de page pour voir.)

Explication:

9L                # Create a list of size 9
  ε               # Change each value to:
   9L             #  Create a list in the range [1, 9]
     N3*N3÷+      #  Calculate N*3 + N//3 (where N is the 0-indexed index,
                  #                        and // is integer-division)
            ._    #  Rotate that many times towards the left

Les deux réponses donnent le Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

Octave et Matlab, 50 48 29 octets

mod((1:9)+['furRaghAt']',9)+1

Essayez-le en ligne!

-2 grâce à Johnathon frech

-14 grâce à la suggestion d'ajout de Sanchises Broadcast, qui a également souligné la non-compatibilité.

-5 en remarquant que le vecteur peut être écrit en matlab avec une chaîne de caractères et une transposition.

Était intuitif, maintenant non. Utilise la sommation de diffusion pour répartir 1: 9 sur 9 lignes, réparties par des valeurs déterminées par la chaîne de caractères.

Carte Sudoku produite:

 5 6 7 8 9 1 2 3 4
 2 3 4 5 6 7 8 9 1
 8 9 1 2 3 4 5 6 7
 3 4 5 6 7 8 9 1 2
 9 1 2 3 4 5 6 7 8
 6 7 8 9 1 2 3 4 5
 7 8 9 1 2 3 4 5 6
 4 5 6 7 8 9 1 2 3
 1 2 3 4 5 6 7 8 9

Haskell , 41 octets

[[x..9]++[1..x-1]|x<-[1,4,7,2,5,8,3,6,9]]

Essayez-le en ligne!

Java 10, 82 75 octets

v->{for(int i=81;i-->0;)System.out.print((i/9*10/3+i)%9+1+(i%9<1?" ":""));}

-7 octets en créant un port d'une des réponses Python 2 de @TFeld .

Essayez-le en ligne.

Explication:

v->{                    // Method with empty unused parameter and no return-type
  for(int i=81;i-->0;)  //  Loop `i` in the range (81, 0]
    System.out.print(   //   Print:
     (i/9               //    (`i` integer-divided by 9,
         *10            //     then multiplied by 10,
         /3             //     then integer-divided by 3,
           +i)          //     and then we add `i`)
             %9         //    Then take modulo-9 on the sum of that above
               +1       //    And finally add 1
    +(i%9<1?            //    Then if `i` modulo-9 is 0:
            " "         //     Append a space delimiter
           :            //    Else:
            ""));}      //     Append nothing more

Génère le sudoku suivant (espace délimité au lieu des sauts de ligne comme ci-dessous):

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321

Python - 81 octets

l=list(range(1,10))
for i in range(1,10):print(l);l=l[3+(i%3==0):]+l[:3+(i%3==0)]

Essayez-le en ligne

J'aime avoir 81 octets, mais après quelques optimisations :(

Python 2-75 68 59 58 octets

-7 octets grâce à @DLosc

-9 octets grâce à @Mnemonic

-1 octet grâce à @JoKing

l=range(1,10)
for i in l:print l;j=i%3<1;l=l[3+j:]+l[:3+j]

Essayez-le en ligne

Rubis , 34 octets

(a=*1..9).map{|x|p a.rotate x*3.3}

Essayez-le en ligne!

R , 54 octets

x=1:9;for(y in(x*3)%%10)print(c(x[-(1:y)],x[(1:y)]))

Sortie:

[1] 4 5 6 7 8 9 1 2 3
[1] 7 8 9 1 2 3 4 5 6
[1] 1 2 3 4 5 6 7 8 9
[1] 3 4 5 6 7 8 9 1 2
[1] 6 7 8 9 1 2 3 4 5
[1] 9 1 2 3 4 5 6 7 8
[1] 2 3 4 5 6 7 8 9 1
[1] 5 6 7 8 9 1 2 3 4
[1] 8 9 1 2 3 4 5 6 7

Essayez-le en ligne!

Un grand merci à @Shaggy!

JavaScript (Node.js) , 61 octets

t=>[...s='123456789'].map(e=>s.slice(t=e*3.3%9)+s.slice(0,t))

Essayez-le en ligne!

MathGolf , 16 11 octets

9{9╒♂ï*3/Ä╫

Essayez-le en ligne!

5 octets enregistrés grâce à JoKing

Toile , 13 11 octets

◂ｊ３［«３［Ｔ３［«

Essayez-le ici!

C (clang) , 65 octets

f(i){for(i=0;i<81;)printf("%d%c",(i/9*10/3+i)%9+1,i++%9>7?10:9);}

La fonction peut désormais être réutilisée

Essayez-le en ligne!

K (ngn / k) , 16 octets

1+9!(<9#!3)+\:!9

Essayez-le en ligne!

Première réponse en ngn / k, faite avec une grande aide de l'homme lui-même, @ngn.

Comment:

1+9!(<9#!3)+\:!9 // Anonymous fn
              !9 // Range [0..8]
    (     )+\:   // Sum (+) that range with each left (\:) argument
        !3       // Range [0..2]
      9#         // Reshaped (#) to 9 elements: (0 1 2 0 1 2 0 1 2)
     <           // Grade up
  9!             // Modulo 9
1+               // plus 1

Japt, 11 10 octets

9õ ñu3
£éX

Essayez-le ou vérifiez la sortie

Explication

9õ         :Range [1,9]
   ñ       :Sort by
    u3     :  Mod 3 of each
\n         :Assign to variable U
£          :Map each X
 éX        :  U rotated right by X

Fusain , 14 octets

Ｅ⁹⭆⁹⊕﹪⁺÷×χι³λ⁹

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

Ｅ⁹              Map over 9 rows
  ⭆⁹            Map over 9 columns and join
          ι     Current row
         χ      Predefined variable 10
        ×       Multiply
       ÷   ³    Integer divide by 3
            λ   Current column
      ⁺         Add
     ﹪       ⁹  Modulo 9
    ⊕           Increment
                Implicitly print each row on its own line