Saída de uma placa Sudoku


25

O desafio de hoje é simples: sem receber nenhuma entrada, produza qualquer placa sudoku válida.

Caso você não esteja familiarizado com o sudoku, a Wikipedia descreve como deve ser uma placa válida :

O objetivo é preencher uma grade 9 × 9 com dígitos para que cada coluna, cada linha e cada uma das nove subgrades 3 × 3 que compõem a grade (também chamadas de "caixas", "blocos" ou "regiões") contenham todos os dígitos de 1 a 9.

Agora, aqui está a coisa ... Existem 6.670.903.752.021.072.936.960 diferentes placas de sudoku válidas . Alguns deles podem ser muito difíceis de compactar e produzir em menos bytes. Outros podem ser mais fáceis. Parte desse desafio é descobrir quais placas serão mais compactáveis ​​e poderão ser produzidas no menor número de bytes.

Seu envio não precisa necessariamente gerar o mesmo quadro sempre. Mas se várias saídas forem possíveis, você terá que provar que todas as saídas possíveis são uma placa válida.

Você pode usar esse script (graças ao Magic Octopus Urn) ou qualquer uma dessas respostas para verificar se uma determinada grade é uma solução válida. Ele produzirá a [1]para uma placa válida e qualquer outra coisa para uma placa inválida.

Não sou muito exigente em qual formato você envia sua resposta, desde que seja claramente bidimensional. Por exemplo, você pode gerar uma matriz 9x9, nove matrizes 3x3, uma sequência, uma matriz de sequências, uma matriz de números inteiros de 9 dígitos ou nove números de 9 dígitos com um separador. Não é permitido emitir 81 dígitos em 1 dimensão. Se você gostaria de saber sobre um formato de saída específico, não hesite em me perguntar nos comentários.

Como de costume, isso é , então escreva a resposta mais curta que você puder encontrar no (s) idioma (s) de sua escolha!


Podemos produzir três matrizes 3x9? Cada linha de cada submatriz que representa uma linha no quadro de sudoku. Como este
dylnan

2
Relacionado, mas não um idiota . Além disso, se você estiver permitindo uma saída flexível, não tenho certeza de que a complexidade do kolmogorov se aplique, já que normalmente é para saídas fixas, como arte ascii exata.
BradC

Respostas:


13

Pitão, 22 14 12 10 bytes

.<LS9%D3 9

Economizou 2 bytes graças ao Sr. Xcoder.

Experimente aqui

.<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.
Mr. Xcoder

Atravessar isso, 10: .<LS9%D3 9.
Mr. Xcoder

Pode querer atualizar o link ( tio )
bryc 26/11


8

T-SQL, 96 89 bytes

Encontrado um menor que a saída trivial!

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

Extrai seqüências de 9 caracteres começando em pontos diferentes, conforme definido pela tabela na memória criada por STRING_SPLIT(que é suportada no SQL 2016 e posterior). A 0+valueera o caminho mais curto que eu poderia fazer uma conversão implícita de um inteiro.

Saída 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]

Experimente online!


Alternativas:

Python 2 , 53 bytes

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

Experimente online!

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

Experimente online!

  • -3 bytes graças a Jo King,

Os elementos da cadeia de bytes acabam dando os números [1, 4, 7, 2, 5, 8, 3, 6, 9]que são usados ​​para permitir as rotações de [0..9]. O 0é removido l[1:i]e não há necessidade de um byte nulo, que leva dois caracteres ( \0) para representar em um objeto de bytes.

55 bytes

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


@JoKing Clever, obrigado
dylnan

4

Geléia , 9 8 bytes

9Rṙ`s3ZẎ

Experimente online!

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%%

Usa a saída do @ Mnemonic. callé usado para interpolar a variável na operação de fatiar (normalmente ela aceita apenas constantes numéricas).



4

Perl 6 , 40 32 27 bytes

-5 bytes graças a nwellnhof

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

Experimente online!

Bloco de código anônimo que retorna uma matriz 9x9. Mapeia cada linha para uma rotação diferente do intervalo de 1 a 9.


4

J , 18 bytes

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

Experimente online!

Saída

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

Como 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

Versão extravagante, 23 bytes

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

Experimente online!

Saída:

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

Como 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 através da criação de uma porta de @Mnemonic resposta Pyth 's .

Experimente online. (O rodapé é adicionado para uma impressão bonita. O resultado real é uma matriz 9x9; fique à vontade para remover o rodapé para ver.)

Explicação:

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

Solução original de 14 bytes :

9Lε9LN3*N3÷+._

Experimente online. (O rodapé é adicionado para uma impressão bonita. O resultado real é uma matriz 9x9; fique à vontade para remover o rodapé para ver.)

Explicação:

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 as respostas resultam no Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

4

Oitava e Matlab, 50 48 29 bytes

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

Experimente online!

-2 graças a Johnathon frech

-14 graças à sugestão de adição da Sanchises Broadcast, que também apontou a não compatibilidade.

-5 ao perceber que o vetor pode ser escrito no matlab com uma string de caracteres e transposição.

Era intuitivo, agora não é assim. Usa a soma de difusão para espalhar 1: 9 por 9 linhas, espalhada por valores determinados pela sequência de caracteres.

Quadro Sudoku produzido:

 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

Olá e bem-vindo ao PPCG; bom primeiro post.
Jonathan Frech 24/09


Obviamente, s poderia ser definido na própria matriz. Eu devo ter contado os bytes também.
Poptimist 24/09

Agora é o Octave, não é mais compatível com o MATLAB. Se desejar, você pode usar o ícone da correntinha na parte superior do link de Jonathan para copiar e colar a formatação PPCG padrão.
Sanchises

Se quiser, você pode reduzir para 34 bytes com a adição de transmissão: Experimente online!
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, criando uma porta de uma das respostas Python 2 do @TFeld .

Experimente online.

Explicação:

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

Produz o seguinte sudoku (espaço delimitado em vez de novas linhas, como abaixo):

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

Experimente Online

Eu gosto de ter 81 bytes, mas depois de alguma otimização :(

Python 2-75 68 59 58 bytes

-7 bytes graças a @DLosc

-9 bytes graças a @Mnemonic

-1 byte graças a @JoKing

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

Experimente Online


2
81 bytes Pontuação perfeita! : D
DJMcMayhem

@DJMcMayhem eu estava pensando em fazer-lo mais curto, fazendo r=range(1,10), mas eu não podia estragar a beleza
Don Thousand


@DLosc Ooh reutilização inteligente del
Don Thousand

Se você não se importa com o Python 2, pode retirar os parênteses da impressão e remover a embalagem da lista.


2

R , 54 bytes

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

Saída:

[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

Experimente online!





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);}

A função agora pode ser reutilizada

Experimente online!


Em vez de imprimir um byte NUL para separar seus dígitos, você pode usar um caractere de tabulação na mesma contagem de bytes.
Jonathan Frech 24/09

"Sua submissão não precisa necessariamente gerar a mesma placa sempre. Mas se várias saídas forem possíveis, você terá que provar que toda saída possível é uma placa válida". Não diz que são necessárias várias saídas. @ceilingcat
Logern

1
@ Logern A regra em questão é que os envios de funções precisam ser reutilizáveis . Não há problema em f(); f()emitir a mesma placa duas vezes, mas não se a segunda chamada não funcionar.
Anders Kaseorg 25/09/18


61 bytes, incorporando sugestões de @JoKingf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
roofcat

1

K (ngn / k) , 16 bytes

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

Experimente online!

Primeira resposta em ngn / k, feita com uma grande ajuda do próprio homem, @ngn.

Quão:

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

Japonês, 11 10 bytes

9õ ñu3
£éX

Experimente ou verifique a saída


Explicação

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

Carvão , 14 bytes

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

Experimente online! Link é a versão detalhada do código. Usa a saída do @ Mnemonic. Explicação:

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.