Sortie d'une carte Sudoku

25

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!

code-golf  kolmogorov-complexity  grid  sudoku 
— DJMcMayhem
source
Peut-on produire trois matrices 3x9? Chaque ligne de chaque sous-matrice représentant une ligne du tableau sudoku. Comme ça
— dylnan
2
Lié mais pas dup . De plus, si vous autorisez une sortie flexible, je ne suis pas sûr que la complexité kolmogorov s'applique, car c'est normalement pour des sorties fixes comme l'art ascii exact.
— BradC

Réponses:

13

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.
11: m.<S9d%D3 9.
— M. Xcoder
Traversez que sur 10: .<LS9%D3 9.
— M. Xcoder
Je
— pourrais
8

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'
— BradC
source
6

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]
— TFeld
source
5

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])
— dylnan
source
— Jo King
@JoKing Clever, thanks
— dylnan
4

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.
— dylnan
source
4

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).

— Neil
source
4

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.

— Jo King
source
4

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
— Bubbler
source
4

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
— Kevin Cruijssen
source
4

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
— Poptimist
source
Bonjour et bienvenue chez PPCG; joli premier post.
— Jonathan Frech
— Jonathan Frech
Bien sûr, s pourrait être défini dans la matrice elle-même. Je dois aussi avoir mal compté les octets.
— Poptimist
C'est maintenant Octave, qui n'est plus compatible avec MATLAB. Si vous le souhaitez, vous pouvez utiliser la petite icône de chaîne en haut du lien de Jonathan pour copier-coller le formatage PPCG par défaut.
— Sanchises
Si vous le souhaitez, vous pouvez le réduire à 34 octets avec l'ajout de diffusion: essayez-le en ligne!
— Sanchises
3

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
— Kevin Cruijssen
source
2

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

— Don mille
source
2
81 octets Score parfait! : D
— DJMcMayhem
@DJMcMayhem J'envisageais de le raccourcir en le faisant r=range(1,10)mais je ne pouvais pas ruiner la beauté
— Don Thousand
— DLosc
@DLosc Ooh réutilisation intelligente del
— Don Thousand
Si cela ne vous dérange pas Python 2, vous pouvez retirer les parens de l'impression et supprimer l'emballage de la liste.
2

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!

— DobromirM
source
1

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!

— Logern
source
Au lieu d'imprimer un octet NUL pour séparer vos chiffres, vous pouvez utiliser un caractère de tabulation avec le même nombre d'octets.
— Jonathan Frech
"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." Il ne dit pas que plusieurs sorties sont nécessaires. @ceilingcat
— Logern
1
@Logern La règle en question est que les soumissions de fonctions doivent être réutilisables . C'est bien s'il f(); f()sort deux fois la même carte, mais pas si le deuxième appel ne fonctionne pas du tout.
— Anders Kaseorg
— Jo King
61 octets, intégrant les suggestions de @JoKingf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
— plafondcat
1

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
— J. Sallé
source
0

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
— Neil
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.