El desafío de hoy es simple: sin tomar ninguna entrada, dar salida a cualquier tablero de sudoku válido.

En caso de que no esté familiarizado con el sudoku, Wikipedia describe cómo debería ser un tablero válido :

El objetivo es llenar una cuadrícula de 9 × 9 con dígitos para que cada columna, cada fila y cada una de las nueve subcuadrículas de 3 × 3 que componen la cuadrícula (también llamadas "cuadros", "bloques" o "regiones") contengan todos los dígitos del 1 al 9.

Ahora aquí está la cosa ... Hay 6.670.903.752.021.072.936.960 diferentes tablas de sudoku válidas . Algunos de ellos pueden ser muy difíciles de comprimir y generar en menos bytes. Otros de ellos pueden ser más fáciles. Parte de este desafío es determinar qué placas serán más comprimibles y podrían emitirse en la menor cantidad de bytes.

Su envío no necesariamente tiene que generar el mismo tablero cada vez. Pero si son posibles múltiples salidas, tendrá que demostrar que cada salida posible es una placa válida.

Puede usar este script (gracias a Magic Octopus Urn) o cualquiera de estas respuestas para verificar si una cuadrícula en particular es una solución válida. Producirá una [1]para una placa válida y cualquier otra cosa para una placa no válida.

No soy demasiado exigente con respecto al formato en el que genera su respuesta, siempre que sea claramente bidimensional. Por ejemplo, podría generar una matriz de 9x9, nueve matrices de 3x3, una cadena, una matriz de cadenas, una matriz de enteros de 9 dígitos o nueve números de 9 dígitos con un separador. No se permitiría generar 81 dígitos en 1 dimensión. Si desea saber acerca de un formato de salida en particular, no dude en preguntarme en los comentarios.

Como de costumbre, este es el código de golf , ¡así que escriba la respuesta más corta que pueda encontrar en el idioma o idiomas que elija!

Pyth, 22 14 12 10 bytes

.<LS9%D3 9

Guardado 2 bytes gracias al Sr. Xcoder.

Pruébalo aquí

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

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

Pruébalo en línea!

T-SQL, 96 89 bytes

¡Encontré uno más corto que el trivial!

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

Extrae cadenas de 9 caracteres que comienzan en diferentes puntos, tal como se define en la tabla en memoria creada por STRING_SPLIT(que es compatible con SQL 2016 y versiones posteriores). El 0+valueera el camino más corto que podía hacer una conversión implícita al número entero.

Salida trivial original (96 bytes):

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

Jalea , 7 bytes

9Rṙ%3$Þ

Pruébalo en línea!

Y un poco de esto ...
-1 gracias a Jonathan Allan (¿está pensando?)

Python 2 , 53 bytes

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

Pruébalo en línea!

Alternativas:

Python 2 , 53 bytes

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

Pruébalo en línea!

Python 2 , 54 bytes

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 bytes

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

Pruébalo en línea!

• -3 bytes gracias a Jo King,

Los elementos de la cadena de bytes terminan dando los números [1, 4, 7, 2, 5, 8, 3, 6, 9]que se utilizan para permutar las rotaciones de [0..9]. Se 0elimina l[1:i]y no hay necesidad de un byte nulo que tome dos caracteres ( \0) para representar en un objeto de bytes.

55 bytes

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

Jalea , 9 8 bytes

9Rṙ`s3ZẎ

Pruébalo en línea!

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.

Lote, 84 bytes

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

Utiliza la salida de @ Mnemonic. callse usa para interpolar la variable en la operación de corte (normalmente solo acepta constantes numéricas).

JavaScript (Node.js) , 47 bytes

Salida como una matriz de las filas.

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

Pruébalo en línea!

Genera esto:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6 , 40 32 27 bytes

-5 bytes gracias a nwellnhof

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

Pruébalo en línea!

Bloque de código anónimo que devuelve una matriz de 9x9. Asigna cada fila a una rotación diferente del rango de 1 a 9.

J , 18 bytes

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

Pruébalo en línea!

Salida

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

Cómo funciona

>:(,&|:|."{,)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

Versión de lujo, 23 bytes

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

Pruébalo en línea!

Salida:

┌─────┬─────┬─────┐
│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│
└─────┴─────┴─────┘

Cómo funciona

|.&(>: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 bytes

8ÝΣ3%}ε9Ls._

-2 bytes mediante la creación de un puerto de @Mnemonic Pyth respuesta 's .

Pruébalo en línea. (Se agrega el pie de página para imprimirlo. El resultado real es una matriz de 9x9; no dude en quitar el pie de página para verlo).

Explicación:

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

Solución original de 14 bytes :

9Lε9LN3*N3÷+._

Pruébalo en línea. (Se agrega el pie de página para imprimirlo. El resultado real es una matriz de 9x9; no dude en quitar el pie de página para verlo).

Explicación:

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

Ambas respuestas dan como resultado el Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

Octave y Matlab, 50 48 29 bytes

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

Pruébalo en línea!

-2 gracias a Johnathon frech

-14 gracias a la sugerencia de adición de Sanchises Broadcast, que también señaló la no compatibilidad.

-5 al notar que el vector se puede escribir en matlab con una cadena de caracteres y transposición.

Era intuitivo, ahora no es así. Utiliza la suma de difusión para distribuir 1: 9 en 9 filas, distribuidas por valores determinados por la cadena de caracteres.

Tablero de Sudoku producido:

 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 bytes

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

Pruébalo en línea!

Java 10, 82 75 bytes

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

-7 bytes creando un puerto de una de las respuestas de Python 2 de @TFeld .

Pruébalo en línea.

Explicación:

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

Muestra el siguiente sudoku (espacio delimitado en lugar de líneas nuevas como se muestra a continuación):

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321

Python - 81 bytes

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

Pruébalo en línea

Me gusta tener 81 bytes, pero después de algunas optimizaciones :(

Python 2 - 75 68 59 58 bytes

-7 bytes gracias a @DLosc

-9 bytes gracias a @Mnemonic

-1 byte gracias a @JoKing

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

Pruébalo en línea

Ruby , 34 bytes

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

Pruébalo en línea!

R , 54 bytes

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

Salida:

[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

Pruébalo en línea!

Muchas gracias a @Shaggy!

JavaScript (Node.js) , 61 bytes

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

Pruébalo en línea!

MathGolf , 16 11 bytes

9{9╒♂ï*3/Ä╫

Pruébalo en línea!

Guardado 5 bytes gracias a JoKing

Lienzo , 13 11 bytes

◂ｊ３［«３［Ｔ３［«

Pruébalo aquí!

C (clang) , 65 bytes

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

La función ahora se puede reutilizar

Pruébalo en línea!

K (ngn / k) , 16 bytes

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

Pruébalo en línea!

Primera respuesta en ngn / k, hecha con una gran ayuda del hombre mismo, @ngn.

Cómo:

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 bytes

9õ ñu3
£éX

Pruébalo o verifica la salida

Explicación

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

Carbón , 14 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Utiliza la salida de @ Mnemonic. Explicación:

Ｅ⁹              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