Die heutige Herausforderung ist einfach: Ohne Eingabe eine gültige Sudoku-Karte ausgeben.

Falls Sie mit Sudoku nicht vertraut sind, beschreibt Wikipedia, wie ein gültiges Forum aussehen sollte :

Das Ziel besteht darin, ein 9 × 9-Raster mit Ziffern zu füllen, sodass jede Spalte, jede Zeile und jedes der neun 3 × 3-Teilraster, aus denen das Raster besteht (auch als "Felder", "Blöcke" oder "Regionen" bezeichnet), enthält alle Ziffern von 1 bis 9.

Hier ist die Sache ... Es gibt 6.670.903.752.021.072.936.960 verschiedene gültige Sudoku-Boards . Einige von ihnen sind möglicherweise sehr schwer zu komprimieren und in weniger Bytes auszugeben. Andere von ihnen können einfacher sein. Ein Teil dieser Herausforderung besteht darin, herauszufinden, welche Karten am komprimierbarsten sind und in den wenigsten Bytes ausgegeben werden können.

Ihr Beitrag muss nicht jedes Mal dasselbe Board ausgeben. Wenn jedoch mehrere Ausgänge möglich sind, müssen Sie beweisen, dass jeder mögliche Ausgang eine gültige Karte ist.

Sie können dieses Skript (dank Magic Octopus Urn) oder eine dieser Antworten verwenden , um zu überprüfen, ob ein bestimmtes Raster eine gültige Lösung ist. Es wird ein [1]für eine gültige Karte und alles andere für eine ungültige Karte ausgegeben .

Ich bin nicht sehr wählerisch, in welchem ​​Format Sie Ihre Antwort ausgeben, solange es eindeutig zweidimensional ist. Sie können beispielsweise eine 9x9-Matrix, neun 3x3-Matrizen, eine Zeichenfolge, ein Array von Zeichenfolgen, ein Array von 9-stelligen Ganzzahlen oder neun 9-stellige Zahlen mit einem Trennzeichen ausgeben. Die Ausgabe von 81 Ziffern in einer Dimension ist nicht zulässig. Wenn Sie etwas über ein bestimmtes Ausgabeformat wissen möchten, können Sie mich gerne in den Kommentaren fragen.

Wie üblich ist dies Codegolf , schreiben Sie also die kürzeste Antwort, die Sie finden können, in die Sprache (n) Ihrer Wahl!

Pyth, 22 14 12 10 Bytes

.<LS9%D3 9

2 Bytes gespart dank Mr. Xcoder.

Probieren Sie es hier aus

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

Probieren Sie es online!

T-SQL, 96 89 Bytes

Fand einen kürzer als die triviale Ausgabe!

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

Extrahiert Zeichenfolgen mit 9 Zeichen, die an verschiedenen Punkten beginnen, wie in der von erstellten In-Memory-Tabelle definiert STRING_SPLIT(die in SQL 2016 und höher unterstützt wird). Das 0+valuewar der kürzeste Weg, wie ich eine implizite Umwandlung in eine Ganzzahl durchführen konnte.

Ursprüngliche triviale Ausgabe (96 Bytes):

PRINT'726493815
315728946
489651237
852147693
673985124
941362758
194836572
567214389
238579461'

Gelee , 7 Bytes

9Rṙ%3$Þ

Probieren Sie es online!

Und ein bisschen davon ...
-1 danke an Jonathan Allan (überlegt?)

Python 2 , 53 Bytes

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

Probieren Sie es online!

Alternativen:

Python 2 , 53 Bytes

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

Probieren Sie es 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])

Probieren Sie es online!

• -3 Bytes dank Jo King,

Die Elemente der Bytekette ergeben am Ende die Zahlen, mit [1, 4, 7, 2, 5, 8, 3, 6, 9]denen die Rotationen von permutiert werden [0..9]. Das 0wird in entfernt, l[1:i]und es ist kein Null-Byte erforderlich, das zwei Zeichen ( \0) für die Darstellung in einem Byte-Objekt benötigt.

55 Bytes

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

Gelee , 9 8 Bytes

9Rṙ`s3ZẎ

Probieren Sie es 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.

Batch, 84 Bytes

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

Verwendet die Ausgabe von @ Mnemonic. callwird verwendet, um die Variable in die Slicing-Operation zu interpolieren (normalerweise akzeptiert sie nur numerische Konstanten).

JavaScript (Node.js) , 47 Byte

Ausgabe als Array der Zeilen.

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

Probieren Sie es online!

Erzeugt dies:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6 , 40 32 27 Bytes

-5 bytes dank nwellnhof

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

Probieren Sie es online!

Anonymer Codeblock, der eine 9x9-Matrix zurückgibt. Ordnet jede Zeile einer anderen Drehung des Bereichs 1 bis 9 zu.

J , 18 Bytes

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

Probieren Sie es online!

Ausgabe

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

Wie es funktioniert

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

Ausgefallene Version, 23 Bytes

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

Probieren Sie es online!

Ausgabe:

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

Wie es funktioniert

|.&(>: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 durch Erstellen eines Ports von @Mnemonics Pyth-Antwort .

Probieren Sie es online aus. (Die Fußzeile wird hinzugefügt, um sie hübsch auszudrucken. Das tatsächliche Ergebnis ist eine 9x9-Matrix. Sie können die Fußzeile auch entfernen, um sie zu sehen.)

Erläuterung:

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

Ursprüngliche 14- Byte- Lösung:

9Lε9LN3*N3÷+._

Probieren Sie es online aus. (Die Fußzeile wird hinzugefügt, um sie hübsch auszudrucken. Das tatsächliche Ergebnis ist eine 9x9-Matrix. Sie können die Fußzeile auch entfernen, um sie zu sehen.)

Erläuterung:

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

Beide Antworten ergeben das Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

Octave & Matlab, 50 48 29 Bytes

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

Probieren Sie es online!

-2 danke an Johnathon frech

-14 Dank an Sanchises Broadcast Hinzufügungsvorschlag, der auch auf die Nichtkompatibilität hinwies.

-5, indem festgestellt wird, dass der Vektor mit einer Zeichenfolge und einer Transposition in matlab geschrieben werden kann.

War intuitiv, jetzt nicht so. Verwendet die Broadcast-Summierung, um 1: 9 auf 9 Zeilen zu verteilen, verteilt nach Werten, die durch die Zeichenfolge bestimmt werden.

Sudoku Board hergestellt:

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

Probieren Sie es 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, indem Sie einen Port für eine der Python 2-Antworten von @TFeld erstellen .

Probieren Sie es online aus.

Erläuterung:

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

Gibt das folgende Sudoku aus (Leerzeichen anstelle von Zeilenumbrüchen wie unten):

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

Probieren Sie es online

Ich mag 81 Bytes, aber nach einigem Optimieren :(

Python 2 - 75 68 59 58 Bytes

-7 Bytes dank @DLosc

-9 Bytes dank @Mnemonic

-1 Byte dank @JoKing

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

Probieren Sie es online

Ruby , 34 Bytes

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

Probieren Sie es online!

R , 54 Bytes

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

Ausgabe:

[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

Probieren Sie es online!

Vielen Dank an @Shaggy!

JavaScript (Node.js) , 61 Byte

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

Probieren Sie es online!

MathGolf , 16 11 Bytes

9{9╒♂ï*3/Ä╫

Probieren Sie es online!

5 Bytes gespart dank JoKing

Canvas , 13 11 Bytes

◂ｊ３［«３［Ｔ３［«

Probieren Sie es hier aus!

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

Die Funktion kann jetzt wieder verwendet werden

Probieren Sie es online!

K (ngn / k) , 16 Bytes

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

Probieren Sie es online!

Erste Antwort in ngn / k, mit großer Hilfe des Mannes selbst, @ngn.

Wie:

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

Japt, 11 10 Bytes

9õ ñu3
£éX

Probieren Sie es aus oder überprüfen Sie die Ausgabe

Erläuterung

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

Holzkohle , 14 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet die Ausgabe von @ Mnemonic. Erläuterung:

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