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!


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

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'


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]

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


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

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



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.


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

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

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

Hola y bienvenidos a PPCG; Buen primer post.
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

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

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


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


@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!





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!


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


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

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

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.