Thử thách ngày nay rất đơn giản: Không cần lấy bất kỳ đầu vào nào, xuất ra bất kỳ bảng sudoku hợp lệ nào.

Trong trường hợp bạn không quen thuộc với sudoku, Wikipedia mô tả một bảng hợp lệ sẽ trông như thế nào :

Mục tiêu là lấp đầy lưới 9 × 9 bằng các chữ số sao cho mỗi cột, mỗi hàng và mỗi chín lớp con 3 × 3 tạo lưới (còn gọi là "hộp", "khối" hoặc "vùng") tất cả các chữ số từ 1 đến 9.

Bây giờ đây là điều ... Có 6.670,903,752,021,072,936,960 bảng sudoku hợp lệ khác nhau . Một số trong số chúng có thể rất khó nén và xuất ra ít byte hơn. Những người khác trong số họ có thể dễ dàng hơn. Một phần của thách thức này là tìm ra những bảng nào sẽ dễ nén nhất và có thể được xuất ra trong vài byte nhất.

Trình của bạn không nhất thiết phải xuất ra cùng một bảng mỗi lần. Nhưng nếu có nhiều kết quả đầu ra, bạn sẽ phải chứng minh rằng mọi đầu ra có thể là một bảng hợp lệ.

Bạn có thể sử dụng tập lệnh này (nhờ Magic Octopus Urn) hoặc bất kỳ câu trả lời nào trong số những câu trả lời này để xác minh xem một lưới cụ thể có phải là một giải pháp hợp lệ hay không. Nó sẽ xuất ra một [1]bảng hợp lệ và bất cứ thứ gì khác cho một bảng không hợp lệ.

Tôi không quá cầu kỳ về định dạng mà bạn đưa ra câu trả lời của mình, miễn là nó rõ ràng 2 chiều. Ví dụ: bạn có thể xuất ma trận 9x9, chín ma trận 3x3, một chuỗi, một chuỗi các chuỗi, một mảng các số nguyên 9 chữ số hoặc chín số có 9 chữ số với một dấu phân cách. Xuất ra 81 chữ số trong 1 chiều sẽ không được phép. Nếu bạn muốn biết về một định dạng đầu ra cụ thể, vui lòng hỏi tôi trong các nhận xét.

Như thường lệ, đây là môn đánh gôn , vì vậy hãy viết câu trả lời ngắn nhất bạn có thể đưa ra bằng ngôn ngữ bạn chọn!

Pyth, 22 14 12 10 byte

.<LS9%D3 9

Lưu được 2 byte nhờ ông Xcoder.

Hãy thử nó ở đây

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

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

Hãy thử trực tuyến!

T-SQL, 96 89 byte

Tìm thấy một ngắn hơn đầu ra tầm thường!

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

Trích xuất các chuỗi 9 ký tự bắt đầu tại các điểm khác nhau, như được xác định bởi bảng trong bộ nhớ được tạo bởi STRING_SPLIT(được hỗ trợ trên SQL 2016 trở lên). Đó 0+valuelà cách ngắn nhất tôi có thể thực hiện chuyển đổi thành ẩn thành số nguyên.

Đầu ra tầm thường ban đầu (96 byte):

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

Thạch , 7 byte

9Rṙ%3$Þ

Hãy thử trực tuyến!

Và một chút về điều này ...
-1 nhờ Jonathan Allan (suy nghĩ của bạn?)

Python 2 , 53 byte

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

Hãy thử trực tuyến!

Lựa chọn thay thế:

Python 2 , 53 byte

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

Hãy thử trực tuyến!

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]

Python 3 , 58 55 byte

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

Hãy thử trực tuyến!

• -3 byte nhờ Jo King,

Các phần tử của chuỗi byte cuối cùng đưa ra các số [1, 4, 7, 2, 5, 8, 3, 6, 9]được sử dụng để hoán vị các phép quay của [0..9]. Cái 0này bị loại bỏ l[1:i]và không cần byte rỗng, cần hai characaters ( \0) để biểu diễn trong một đối tượng byte.

55 byte

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

Thạch , 9 8 byte

9Rṙ`s3ZẎ

Hãy thử trực tuyến!

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.

Mẻ, 84 byte

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

Sử dụng đầu ra của @ Mnemonic. callđược sử dụng để nội suy biến vào hoạt động cắt (thông thường nó chỉ chấp nhận các hằng số).

JavaScript (Node.js) , 47 byte

Đầu ra như một mảng của các hàng.

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

Hãy thử trực tuyến!

Tạo ra điều này:

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6 , 40 32 27 byte

-5 byte nhờ nwellnhof

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

Hãy thử trực tuyến!

Khối mã ẩn danh trả về ma trận 9x9. Ánh xạ mỗi hàng thành một vòng quay khác nhau trong phạm vi từ 1 đến 9.

J , 18 byte

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

Hãy thử trực tuyến!

Đầu ra

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

Làm thế nào nó hoạt động

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

Phiên bản ưa thích, 23 byte

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

Hãy thử trực tuyến!

Đầu ra:

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

Làm thế nào nó hoạt động

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

8ÝΣ3%}ε9Ls._

-2 byte bằng cách tạo ra một cổng của @Mnemonic Pyth câu trả lời 's .

Hãy thử trực tuyến. (Chân trang được thêm vào để in đẹp. Kết quả thực tế là ma trận 9x9; hãy thoải mái loại bỏ chân trang để xem.)

Giải trình:

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

Giải pháp 14 byte gốc :

9Lε9LN3*N3÷+._

Hãy thử trực tuyến. (Chân trang được thêm vào để in đẹp. Kết quả thực tế là ma trận 9x9; hãy thoải mái loại bỏ chân trang để xem.)

Giải trình:

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

Cả hai câu trả lời đều dẫn đến Sudoku:

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

Octave & Matlab, 50 48 29 byte

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

Hãy thử trực tuyến!

-2 nhờ Johnathon frech

-14 nhờ đề xuất bổ sung Phát sóng của Sanchises, người cũng chỉ ra sự không tương thích.

-5 bằng cách nhận thấy rằng vectơ có thể được viết bằng matlab với một chuỗi char và hoán vị.

Đã trực giác, bây giờ không phải như vậy. Sử dụng tổng hợp phát sóng để trải 1: 9 trên 9 hàng, trải theo các giá trị được xác định bởi chuỗi char.

Bảng Sudoku được sản xuất:

 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 byte

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

Hãy thử trực tuyến!

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 bằng cách tạo một cổng của một trong các câu trả lời Python 2 của @TFeld .

Hãy thử trực tuyến.

Giải trình:

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

Xuất ra sudoku sau (giới hạn không gian thay vì dòng mới như bên dưới):

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321

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

Dùng thử trực tuyến

Tôi thích có 81 byte, nhưng sau khi tối ưu hóa :(

Python 2 - 75 68 59 58 byte

-7 byte nhờ @DLosc

-9 byte nhờ @Mnemonic

-1 byte nhờ @JoKing

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

Dùng thử trực tuyến

Ruby , 34 byte

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

Hãy thử trực tuyến!

R , 54 byte

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

Đầu ra:

[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

Hãy thử trực tuyến!

Rất cảm ơn @Shaggy!

JavaScript (Node.js) , 61 byte

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

Hãy thử trực tuyến!

MathGolf , 16 11 byte

9{9╒♂ï*3/Ä╫

Hãy thử trực tuyến!

Đã lưu 5 byte nhờ JoKing

Canvas , 13 11 byte

◂ｊ３［«３［Ｔ３［«

Hãy thử nó ở đây!

C (tiếng kêu) , 65 byte

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

Chức năng hiện có thể được sử dụng lại

Hãy thử trực tuyến!

K (ngn / k) , 16 byte

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

Hãy thử trực tuyến!

Câu trả lời đầu tiên bằng ngn / k, được thực hiện với sự giúp đỡ lớn từ chính người đàn ông, @ngn.

Làm sao:

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 byte

9õ ñu3
£éX

Hãy thử hoặc xác minh đầu ra

Giải trình

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

Than , 14 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Sử dụng đầu ra của @ Mnemonic. Giải trình:

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