以一个正整数n作为输入，并输出一个由1和0组成的n × n棋盘矩阵。

左上角的数字应始终为1。

测试用例：

n = 1
1

n = 2
1 0
0 1

n = 3
1 0 1
0 1 0
1 0 1

n = 4
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1

输入和输出格式是可选的。接受将矩阵输出为列表列表。

果冻，4字节

52秒！

+€ḶḂ

在线尝试！

MATL，5个字节

:otYT

在线尝试在MATL！

说明

以输入4为例。

:    % Implicit input, n. Push range [1 2 ... n]
     %   STACK: [1 2 3 4]
o    % Parity, element-wise
     %   STACK: [1 0 1 0]
t    % Duplicate
     %   STACK: [1 0 1 0], [1 0 1 0]
YT   % Toeplitz matrix with two inputs. Implicit display
     %   STACK: [1 0 1 0;
     %           0 1 0 1;
     %           1 0 1 0;
     5           0 1 0 1]

Japt，6个字节

ÆÇ+X v

在线测试！（使用-Q标志可以更容易地看到）

说明

 Æ   Ç   +X v
UoX{UoZ{Z+X v}}  // Ungolfed
                 // Implicit: U = input number
UoX{          }  // Create the range [0...U), and map each item X to
    UoZ{     }   //   create the range [0...U), and map each item Z to
        Z+X      //     Z + X
            v    //     is divisible by 2.
                 // Implicit: output result of last expression

需要注意的有趣一点是，v它不是内置的“可被2整除”的函数。而是内置了“可被X整除”的功能。但是，与大多数高尔夫语言不同，Japt的功能没有固定的通用性（它们可以接受任意数量的右参数）。当给定0个右参数时，v假定您需要2，因此其行为与给定的一样，2而不是没有给出的情况。

V，16，15字节

Ài10À­ñÙxñÎÀlD

在线尝试！

十六进制转储：

00000000: c069 3130 1bc0 adf1 d978 f1ce c06c 44    .i10.....x...lD

Haskell，50 41 39 38字节

感谢nimi和xnor帮助削减了9个10字节

f n=r[r"10",r"01"]where r=take n.cycle

或者，再增加一个字节：

(!)=(.cycle).take
f n=n![n!"10",n!"01"]

要么：

r=flip take.cycle
f n=r[r"10"n,r"01"n]n

可能不是最佳选择，但是干净，直接的方法。

APL（Dyalog），8字节

~2|⍳∘.+⍳

在线尝试！

说明

让我们称之为参数n。

⍳∘.+⍳

这将创建一个矩阵

1+1 1+2 1+2 .. 1+n
2+1 2+2 2+3 .. 2+n
...
n+1 n+2 n+3 .. n+n

然后2|取矩阵的模2（向量化），然后~取结果的非。

Mathematica，25个字节

1-Plus~Array~{#,#}~Mod~2&

的JavaScript ES6，55 54 51 46字节

@Neil节省了1个字节

@Arnauld节省了2个字节

n=>[...Array(n)].map((_,i,a)=>a.map(_=>++i&1))

在线尝试！

这输出为数组的数组。JavaScript范围非常笨拙，但我使用[...Array(n)]它会生成一个大小数组n

视网膜，33 30字节

.+
$*
1
$_¶
11
10
T`10`01`¶.+¶

在线尝试！说明：第一级使用1s（方便地！）将输入转换为一元，而第二级将值转换为平方。第三级反转每行的交替位，而最后一级反转交替的行。编辑：由于@MartinEnder，节省了3个字节。

MATL，7个字节

:t!+2\~

在线尝试！

说明：

         % Implicit input (n)
:        % Range from 1-n, [1,2,3]
 t       % Duplicate, [1,2,3], [1,2,3]
  !      % Transpose, [1,2,3], [1;2;3]
   +     % Add        [2,3,4; 3,4,5; 4,5,6]
    2    % Push 2     [2,3,4; 3,4,5; 4,5,6], 2
     \   % Modulus    [0,1,0; 1,0,1; 0,1,0]
      ~  % Negate     [1,0,1; 0,1,0; 1,0,1]

_{注意：发布挑战后，我开始在MATL中解决此问题。}

Brachylog，15个字节

^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\

在线尝试！

说明

Example Input: 4

^₂               Square:                            16
  ⟦₁             1-indexed Range:                   [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]
    %₂ᵐ          Map Mod 2:                         [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]
       ;?ḍ₎      Input-Chotomize:                   [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]
           pᵐ.   Map permute such that..
             .\  ..the output is its own transpose: [[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]

Clojure，36个字节

#(take %(partition % 1(cycle[1 0])))

是的，正确的工作工具。

05AB1E，9 7字节

-2字节归功于Emigna

LDÈD_‚è

在线尝试！

说明

LDÈD_‚sè» Argument n
LD        Push list [1 .. n], duplicate
  ÈD      Map is_uneven, duplicate
    _     Negate boolean (0 -> 1, 1 -> 0)
     ‚    List of top two elements of stack
      è   For each i in [1 .. n], get element at i in above created list
          In 05AB1E the element at index 2 in [0, 1] is 0 again

Java（OpenJDK 8），80 77字节

-3个字节，感谢Kevin Cruijssen

j->{String s="1";for(int i=1;i<j*j;s+=i++/j+i%j&1)s+=1>i%j?"\n":"";return s;}

在线尝试！

哦，看，一个半合理长度的Java答案，里面有很多有趣的运算符。

接受一个int并返回一个String的lambda。通过使用行号和列号并使用/和％来确定它应该是哪个值，mod 2；

取消高尔夫：

j->{
    String s="1";
    for(int i=1; i<j*j; s+= i++/j + i%j&1 )
        s+= 1>i%j ? "\n" : "";
    return s;
}

木炭，8个字节

ＵＯＮ10¶01

在线尝试！说明：这大致翻译为以下冗长的代码（不幸的是，deverbosifier当前正在附加不必要的分隔符）：

Oblong(InputNumber(), "10\n01");

Pyth，9个字节

VQm%+hdN2

尝试这个！

另一个9字节的解决方案：

mm%+hdk2Q

试试吧！

J，9个字节

<0&=$&1 0

在线尝试！

Mathematica，23个字节

ToeplitzMatrix@#~Mod~2&

八度，24字节

@(n)~mod((a=(1:n))+a',2)

在线尝试！

或相同的长度：

@(n)mod(toeplitz(1:n),2)

在线尝试！

R，38 37字节

n=scan();(matrix(1:n,n,n,T)+1:n-1)%%2

在线尝试！

-1个字节，感谢Giuseppe

利用R的回收规则，首先是在创建矩阵时，其次是在该矩阵上添加0：（n-1）。

Swi-Prolog，142个字节。

t(0,1).
t(1,0).
r([],_).
r([H|T],H):-t(H,I),r(T,I).
f([],_,_).
f([H|T],N,B):-length(H,N),r(H,B),t(B,D),f(T,N,D).
c(N,C):-length(C,N),f(C,N,1).

在线尝试-http: //swish.swi-prolog.org/p/BuabBPrw.pl

它输出一个嵌套列表，所以规则说：

• t() 是一个切换，它使0-> 1和1-> 0。
• r() 对于单个行成功执行，这是对行进行递归检查，确定行仅是交替的零。
• f()递归检查所有行，它们的长度正确，是否是有效行，r()并且每行以不同的0/1开头。
• c(N,C) 说如果行（嵌套列表）的数量为N，则C是大小为N的有效棋盘，并且帮助程序f成功。

测试用例：

C，69 67 63字节

感谢@Kevin Cruijssen保存了两个字节，而@ceilingcat保存了四个字节！

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j;)printf("%d",j--+i&1);}

在线尝试！

QBIC，19个字节

[:|?[b|?(a+c+1)%2';

说明

[:|         FOR a = 1 to b (b is read from cmd line)
?           PRINT - linsert a linebreak in the output
[b|         FOR c = 1 to b
?(a+c+1)%2  PRINT a=c=1 modulo 2 (giving us the 1's and 0's
';            PRINT is followed b a literal semi-colon, suppressing newlines and 
              tabs. Printing numbers in QBasic adds one space automatically.

Brachylog，19个字节

⟦₁Rg;Rz{z{++₁%₂}ᵐ}ᵐ

在线尝试！

PHP，56字节

输出为字符串

for(;$i<$argn**2;)echo++$i%2^$n&1,$i%$argn?"":"
".!++$n;

在线尝试！

PHP，66字节

输出为2 D数组

for(;$i<$argn**2;$i%$argn?:++$n)$r[+$n][]=++$i%2^$n&1;print_r($r);

在线尝试！

CJam，17个字节

{_[__AAb*<_:!]*<}

在线尝试！

返回列表（TIO链接已格式化输出）。

Bash + RS，42岁

eval echo \$[~{1..$1}+{1..$1}\&1]|rs $1 $1

在线尝试。

切达（Cheddar），38个字节

n->(|>n).map(i->(|>n).map(j->i+j+1&1))

在线尝试！

///，87字节+输入

/V/\\\///D/VV//*/k#D#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&[unary input in asterisks]

在线尝试！（输入4）

以1s为单位的一元输入，95字节+输入

/V/\\\///D/VV//&1/k#&D&|D/#k/k#D&k/k&DVk/k\D/SD/#/r
DSkk/10DSk/1D&/V#rV#0r;VV0;VVV1;V\D/r/S/&&[unary input in ones]|

在线尝试！（输入8）

这是如何运作的？

• V和D分别去打高尔夫\/和//。

• /*/k#/并将/&1/k#&//&|//输入分离为'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//将所有ks移至/r/S/块

• Ss仅用于填充ks 在s之后/的实例，以便它们不会移到其他位置，然后将Ss删除

• #s然后变成r\ns

• ks 的字符串变成交替的1010...字符串

• 该r\ns的变成了1010...\n小号

• 每对1010...\n1010\n变成1010...\01010...;\n

• 任一0;或1;被修剪掉（因为01010...字符串太长通过1）

Mathematica，28个字节

Cos[+##/2Pi]^2&~Array~{#,#}&

接受正整数作为输入并返回2D数组的纯函数。使用周期函数cos²（πx/ 2）生成1和0。

为了获得更多乐趣，32字节解决方案如何

Sign@Zeta[1-+##]^2&~Array~{#,#}&

它使用黎曼zeta函数的平凡零点的位置。