Salida de un tablero de Sudoku

25

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 , ¡así que escriba la respuesta más corta que pueda encontrar en el idioma o idiomas que elija!

DJMcMayhem
fuente
¿Podemos generar tres matrices 3x9? Cada fila de cada submatriz representa una fila en el tablero de sudoku. Me gusta esto
dylnan
2
Relacionado pero no un dup . Además, si está permitiendo una salida flexible, no estoy seguro de que se aplique la complejidad de kolmogorov , ya que normalmente es para salidas fijas como el arte ascii exacto.
BradC

Respuestas:

13

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.

fuente
11: m.<S9d%D3 9.
Sr. Xcoder
Cruce de eso, 10: .<LS9%D3 9.
Sr. Xcoder
Podría querer actualizar el enlace ( tio )
bryc
8

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'
BradC
fuente
6

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]
TFeld
fuente
5

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])
dylnan
fuente
55 bytes
Jo King
@JoKing Clever, gracias
dylnan
4

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.
dylnan
fuente
4

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

Neil
fuente
4

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

Shieru Asakoto
fuente
4

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.

Jo King
fuente
4

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
Bubbler
fuente
4

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
Kevin Cruijssen
fuente
4

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
Poptimist
fuente
Hola y bienvenidos a PPCG; Buen primer post.
Jonathan Frech
48 bytes .
Jonathan Frech
Por supuesto, s podría definirse en la matriz misma. Debo haber contado mal los bytes también.
Poptimist
Esto ahora es Octave, ya no es compatible con MATLAB. Si lo desea, puede usar el icono de la pequeña cadena en la parte superior del enlace de Jonathan para copiar y pegar el formato PPCG predeterminado.
Sanchises
Si lo desea, puede reducir esto a 34 bytes con la adición de transmisión: ¡ Pruébelo en línea!
Sanchises
3

Haskell , 41 bytes

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

Pruébalo en línea!

Curtis Bechtel
fuente
Esto no es valido. Cada cuadrado contiene múltiplos del mismo número. Se podría hacer algo como esto (43 bytes) en lugar
Jo Rey
¡Gracias! Tomé su sugerencia
Curtis Bechtel
@RushabhMehta lo hice. Era 43 bytes, pero me quita el s=puesto que no es necesario
Curtis Bechtel
3

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
Kevin Cruijssen
fuente
2

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

Don mil
fuente
2
81 bytes ¡Puntuación perfecta! : D
DJMcMayhem
@DJMcMayhem Estaba pensando en hacerlo más corto, r=range(1,10)pero no pude arruinar la belleza
Don Thousand
68 bytes ;)
DLosc
@DLosc Ooh inteligente reutilización del
Don Thousand
Si no le importa Python 2, puede sacar los parentes de la impresión y eliminar el embalaje de la lista.
2

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!

DobromirM
fuente
1

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!

Logern
fuente
En lugar de imprimir un byte NUL para separar sus dígitos, puede usar un carácter de tabulación con el mismo número de bytes.
Jonathan Frech
"Su presentación no necesariamente tiene que generar la misma placa cada vez. Pero si son posibles múltiples salidas, tendrá que demostrar que cada salida posible es una placa válida". No dice que se necesitan múltiples salidas. @ceilingcat
Logern
1
@Logern La regla en cuestión es que los envíos de funciones deben ser reutilizables . Está bien si f(); f()emite la misma placa dos veces, pero no si la segunda llamada no funciona en absoluto.
Anders Kaseorg el
63 bytes
Jo King
61 bytes, incorporando sugerencias de @JoKingf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
ceilingcat el
1

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
J. Sallé
fuente
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
Lanudo
fuente
0

Carbón , 14 bytes

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

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

E⁹              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
fuente