Emetti una scheda Sudoku

25

La sfida di oggi è semplice: senza prendere alcun input, emettere una scheda sudoku valida.

Nel caso in cui non si abbia familiarità con il sudoku, Wikipedia descrive come dovrebbe essere una scheda valida :

L'obiettivo è riempire una griglia 9 × 9 con cifre in modo tale che ogni colonna, ogni riga e ciascuna delle nove subgriglie 3 × 3 che compongono la griglia (chiamate anche "caselle", "blocchi" o "regioni") contengano tutte le cifre da 1 a 9.

Ora ecco la cosa ... Ci sono 6.670.903.752.021.072.936.960 diverse schede di sudoku valide . Alcuni di essi possono essere molto difficili da comprimere e produrre in meno byte. Altri potrebbero essere più facili. Parte di questa sfida è capire quali saranno le schede più comprimibili e potrebbero essere emesse nel minor numero di byte.

Il tuo invio non deve necessariamente produrre sempre la stessa scheda. Ma se sono possibili più uscite, dovrai dimostrare che ogni possibile uscita è una scheda valida.

Puoi usare questo script (grazie a Magic Octopus Urn) o una qualsiasi di queste risposte per verificare se una particolare griglia è una soluzione valida. Produrrà a [1]per una scheda valida e qualsiasi altra cosa per una scheda non valida.

Non sono troppo esigente riguardo al formato in cui hai prodotto la tua risposta, purché sia ​​chiaramente bidimensionale. Ad esempio, è possibile generare una matrice 9x9, nove matrici 3x3, una stringa, una matrice di stringhe, una matrice di numeri interi a 9 cifre o nove numeri a 9 cifre con un separatore. La produzione di 81 cifre in 1 dimensione non sarebbe consentita. Se desideri conoscere un particolare formato di output, non esitare a chiedermelo nei commenti.

Come al solito, questo è code-golf , quindi scrivi la risposta più breve che puoi trovare nella / e lingua / e di tua scelta!

code-golf  kolmogorov-complexity  grid  sudoku 
— DJMcMayhem
fonte
Possiamo produrre tre matrici 3x9? Ciascuna riga di ogni sottotrama che rappresenta una riga nel tabellone del sudoku. In questo modo
— dylnan,
2
Correlato ma non un dup . Inoltre, se si consente un output flessibile, non sono sicuro che si applichi la complessità di kolmogorov , dal momento che questo è normalmente per output fissi come esattamente ascii art.
— BradC

Risposte:

13

Pyth, 22 14 12 10 byte

.<LS9%D3 9

Salvato 2 byte grazie a Mr. Xcoder.

Provalo qui

.<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,
Attraversate che fuori, 10: .<LS9%D3 9.
— Mr. Xcoder,
Potrebbe voler aggiornare il link ( tio )
— bryc il
8

T-SQL, 96 89 byte

Trovato uno più corto dell'output banale!

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

Estrae stringhe di 9 caratteri che iniziano in punti diversi, come definito dalla tabella in memoria creata da STRING_SPLIT(che è supportata su SQL 2016 e versioni successive). Il 0+valuemodo più breve in cui ho potuto eseguire un cast implicito su intero.

Uscita banale originale (96 byte):

PRINT'726493815
315728946
489651237
852147693
673985124
941362758
194836572
567214389
238579461'
— BradC
fonte
6

Python 2 , 53 byte

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

Provalo online!

alternative:

Python 2 , 53 byte

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

Provalo online!

Python 2 , 54 byte

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
fonte
5

Python 3 , 58 55 byte

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

Provalo online!

  • -3 byte grazie a Jo King,

Gli elementi della stringa di byte finiscono per fornire i numeri [1, 4, 7, 2, 5, 8, 3, 6, 9]usati per permutare le rotazioni di [0..9]. La 0viene rimosso l[1:i]e non v'è alcuna necessità di un byte null che richiede due characaters ( \0) per rappresentare un oggetto in byte.

55 byte

_,*l=range(10)
for i in b"	":print(l[i:]+l[:i])
— dylnan
fonte
— Jo King,
@JoKing Clever, grazie
— dylnan,
4

Gelatina , 9 8 byte

9Rṙ`s3ZẎ

Provalo 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.
— dylnan
fonte
4

Lotto, 84 byte

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

Utilizza l'output di @ Mnemonic. callviene utilizzato per interpolare la variabile nell'operazione di taglio (normalmente accetta solo costanti numeriche).

— Neil
fonte
4

Perl 6 , 40 32 27 byte

-5 byte grazie a nwellnhof

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

Provalo online!

Blocco di codice anonimo che restituisce una matrice 9x9. Mappa ogni riga su una rotazione diversa dell'intervallo da 1 a 9.

— Jo King
fonte
4

J , 18 byte

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

Provalo online!

Produzione

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

Come funziona

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

Versione fantasia, 23 byte

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

Provalo online!

Produzione:

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

Come funziona

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

05AB1E , 14 12 byte

8ÝΣ3%}ε9Ls._

-2 byte creando una porta di @Mnemonic Pyth risposta s' .

Provalo online. (Il piè di pagina viene aggiunto per stamparlo piuttosto. Il risultato effettivo è una matrice 9x9; sentiti libero di rimuovere il piè di pagina per vedere.)

Spiegazione:

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

Soluzione originale di 14 byte :

9Lε9LN3*N3÷+._

Provalo online. (Il piè di pagina viene aggiunto per stamparlo piuttosto. Il risultato effettivo è una matrice 9x9; sentiti libero di rimuovere il piè di pagina per vedere.)

Spiegazione:

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

Entrambe le risposte danno come risultato il Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678
— Kevin Cruijssen
fonte
4

Octave & Matlab, 50 48 29 byte

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

Provalo online!

-2 grazie a Johnathon frech

-14 grazie al suggerimento di aggiunta di Sanchises Broadcast, che ha anche sottolineato la non compatibilità.

-5 notando che il vettore può essere scritto in MATLAB con una stringa di caratteri e trasposizione.

Era intuitivo, ora non così. Utilizza la somma di trasmissione per diffondere 1: 9 su 9 righe, distribuite per valori determinati dalla stringa di caratteri.

Tavola Sudoku prodotta:

 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
fonte
Ciao e benvenuto in PPCG; bel primo post.
— Jonathan Frech,
— Jonathan Frech,
Naturalmente, s potrebbe essere definito nella matrice stessa. Devo aver contato male anche i byte.
— Poptimist,
Questo è ora Octave, non più compatibile con MATLAB. Se lo desideri, puoi utilizzare l'icona a catenella nella parte superiore del collegamento di Jonathan per copiare e incollare la formattazione PPCG predefinita.
— Sanchises,
Se lo desideri, puoi ottenere questo fino a 34 byte con l'aggiunta di trasmissione: provalo online!
— Sanchises,
3

Java 10, 82 75 byte

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

-7 byte creando una porta di una delle risposte Python 2 di @TFeld .

Provalo online.

Spiegazione:

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

Emette il seguente sudoku (spazio delimitato invece di newline come di seguito):

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321
— Kevin Cruijssen
fonte
2

Python - 81 byte

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

Provalo online

Mi piace avere 81 byte, ma dopo qualche ottimizzazione :(

Python 2 - 75 68 59 58 byte

-7 byte grazie a @DLosc

-9 byte grazie a @Mnemonic

-1 byte grazie a @JoKing

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

Provalo online

— Don mille
fonte
2
81 byte Punteggio perfetto! : D
— DJMcMayhem
@DJMcMayhem stavo pensando di renderlo più breve facendo r=range(1,10)ma non potevo rovinare la bellezza
— Don Thousand
68 byte ;)
— DLosc
@DLosc Ooh riutilizzo intelligente dil
— Don Thousand
Se non ti dispiace Python 2, puoi togliere le parentesi dalla stampa e rimuovere la confezione dell'elenco.
2

R , 54 byte

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

Produzione:

[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

Provalo online!

— DobromirM
fonte
1

C (clang) , 65 byte

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

Ora è possibile riutilizzare la funzione

Provalo online!

— Logern
fonte
Invece di stampare un byte NUL per separare le cifre, è possibile utilizzare un carattere di tabulazione con lo stesso numero di byte.
— Jonathan Frech,
"La tua presentazione non deve necessariamente produrre sempre la stessa scheda. Ma se sono possibili più uscite, dovrai dimostrare che ogni possibile uscita è una scheda valida." Non dice che sono necessarie più uscite. @ceilingcat
— Logern
1
@Logern La regola in questione è che gli invii di funzioni devono essere riutilizzabili . Va bene se f(); f()emette due volte la stessa scheda, ma non se la seconda chiamata non funziona affatto.
— Anders Kaseorg,
— Jo King,
61 byte, con suggerimenti di @JoKingf(i){for(i=81;i--;)printf("%d%c",(i/9*10/3+i)%9+1,i%9?9:10);}
— ceilingcat,
1

K (ngn / k) , 16 byte

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

Provalo online!

Prima risposta in ngn / k, fatta con un grande aiuto dall'uomo stesso, @ngn.

Come:

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é
fonte
1

Japt, 11 10 byte

9õ ñu3
£éX

Provalo o verifica l'output

Spiegazione

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
— ispido
fonte
0

Carbone , 14 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Utilizza l'output di @ Mnemonic. Spiegazione:

Ｅ⁹              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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.