今天的挑战很简单：无需输入任何内容，即可输出任何有效的数独板。

如果您不熟悉数独，则Wikipedia描述了有效的面板应该是什么样的：

目的是用数字填充9×9网格，以便组成该网格的每列，每一行以及9个3×3子网格（也称为“框”，“块”或“区域”）包含从1到9的所有数字。

现在这就是事情了……有6,670,903,752,021,072,936,960个不同的有效数独板。其中一些可能很难压缩并以较少的字节输出。他们中的其他人可能更容易。挑战的一部分是弄清楚哪些板将是最可压缩的，并且可以以最少的字节输出。

您提交的内容不必每次都输出相同的板。但是，如果可能有多个输出，则必须证明每个可能的输出都是有效的电路板。

您可以使用此脚本（感谢Magic Octopus Urn）或任何这些答案来验证特定网格是否为有效解决方案。它将[1]为有效板输出a ，为无效板输出其他任何内容。

我不太挑剔您输出答案的格式，只要它显然是二维的即可。例如，您可以输出9x9矩阵，9个3x3矩阵，一个字符串，字符串数组，9位整数数组或9个带有分隔符的9位数字。一维输出81位数字是不允许的。如果您想了解特定的输出格式，请随时在评论中问我。

像往常一样，这是代码高尔夫，因此请用您选择的语言写出最短的答案！

Pyth，22 14 12 10字节

.<LS9%D3 9

多亏了Xcoder先生，节省了2个字节。

在这里尝试

.<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个字节

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

在线尝试！

T-SQL，96 89字节

发现比普通输出短一个！

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

提取由不同点开始的9个字符的字符串，这由创建的内存表定义STRING_SPLIT（在SQL 2016及更高版本中受支持）。这0+value是我可以隐式转换为整数的最短方法。

原始平凡的输出（96字节）：

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

果冻，7个字节

9Rṙ%3$Þ

在线尝试！

和一点点这 ...
-1感谢乔纳森·艾伦（的想法？）

Python 2，53字节

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

在线尝试！

备择方案：

Python 2，53字节

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

在线尝试！

Python 2，54个字节

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个字节

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

在线尝试！

• -3个字节，感谢Jo King，

字节字符串的元素最终给出[1, 4, 7, 2, 5, 8, 3, 6, 9]用于置换的旋转的数字[0..9]。的0是在除去l[1:i]并且没有需要一个空字节采用两个characaters（ \0）是一个字节对象来表示。

55字节

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

果冻，9 8字节

9Rṙ`s3ZẎ

在线尝试！

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.

批处理，84字节

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

使用@Mnemonic的输出。call用于将变量插值到切片操作中（通常只接受数字常量）。

JavaScript（Node.js），47字节

输出为行的数组。

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

在线尝试！

生成此：

472583691
583691472
691472583
725836914
836914725
914725836
258369147
369147258
147258369

Perl 6的，40 32 27个字节

-5字节归功于nwellnhof

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

在线尝试！

返回9x9矩阵的匿名代码块。将每一行映射到1到9范围内的不同旋转角度。

J，18个字节

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

在线尝试！

输出量

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

怎么运行的

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

花式版本，23字节

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

在线尝试！

输出：

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

怎么运行的

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

8ÝΣ3%}ε9Ls._

通过创建@Mnemonic的Pyth答案端口来生成-2字节。

在线尝试。（添加了页脚以进行漂亮的打印。实际结果是9x9矩阵；请随时删除页脚以查看。）

说明：

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

原始的14 个字节的解决方案：

9Lε9LN3*N3÷+._

在线尝试。（添加了页脚以进行漂亮的打印。实际结果是9x9矩阵；请随时删除页脚以查看。）

说明：

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

这两个答案都会导致Sudoku：

123456789
456789123
789123456
234567891
567891234
891234567
345678912
678912345
912345678

八度＆Matlab，50 48 29字节

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

在线尝试！

-2感谢Johnathon frech

-14感谢Sanchises Broadcast的补充建议，他也指出了不兼容的情况。

-5通过注意到向量可以用字符串和转置在matlab中编写。

很直观，现在不是。使用广播求和将1：9分布在9行上，并按由char字符串确定的值进行扩展。

数独板制作：

 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个字节

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

在线尝试！

Java 10，82 75字节

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

通过创建@TFeld的Python 2答案之一的端口来获得-7个字节。

在线尝试。

说明：

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

输出以下数独（用空格分隔，而不是如下所示的换行符）：

876543219
543219876
219876543
765432198
432198765
198765432
654321987
321987654
987654321

Python-81个字节

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

在线尝试

我喜欢有81个字节，但是经过一些优化:(

Python 2-75 68 59 58个字节

-7个字节，感谢@DLosc

-9个字节，感谢@Mnemonic

-1字节感谢@JoKing

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

在线尝试

Ruby，34个字节

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

在线尝试！

R，54个字节

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

输出：

[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

在线尝试！

非常感谢@Shaggy！

JavaScript（Node.js），61字节

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

在线尝试！

MathGolf，16 11个字节

9{9╒♂ï*3/Ä╫

在线尝试！

多亏了JoKing，节省了5个字节

画布，13 11 字节

◂ｊ３［«３［Ｔ３［«

在这里尝试！

C（clang），65个字节

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

现在可以重用该功能

在线尝试！

K（ngn / k），16字节

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

在线尝试！

在ngn / k中的第一个答案是在该人自己@ngn的大力帮助下完成的。

怎么样：

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字节

9õ ñu3
£éX

试试看或验证输出

说明

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

木炭，14字节

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

在线尝试！链接是详细版本的代码。使用@Mnemonic的输出。说明：

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