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 é código-golfe , então escreva a resposta mais curta que você puder encontrar no (s) idioma (s) de sua escolha!

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.

Python 2 , 47 bytes

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

Experimente online!

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'

Geléia , 7 bytes

9Rṙ%3$Þ

Experimente online!

E um pouco disso ...
-1 graças 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]

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]

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

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.

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

JavaScript (Node.js) , 47 bytes

Saída como uma matriz das linhas.

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

Experimente online!

Gera isso:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

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.

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

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

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

Haskell , 41 bytes

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

Experimente online!

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

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

Ruby , 34 bytes

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

Experimente online!

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!

Muito obrigado a @Shaggy!

JavaScript (Node.js) , 61 bytes

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

Experimente online!

MathGolf , 16 11 bytes

9{9╒♂ï*3/Ä╫

Experimente online!

Economizou 5 bytes graças ao JoKing

Tela , 13 11 bytes

◂ｊ３［«３［Ｔ３［«

Experimente aqui!

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!

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

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

Carvão , 14 bytes

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

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

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