Lấy một số nguyên dương n làm đầu vào và xuất ra ma trận bảng kiểm tra n-by-n bao gồm 1 và 0 .

Chữ số trên cùng bên trái phải luôn là 1 .

Các trường hợp thử nghiệm:

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

Định dạng đầu vào và đầu ra là tùy chọn. Xuất ra ma trận như một danh sách các danh sách được chấp nhận.

Thạch , 4 byte

52 giây!

+€ḶḂ

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

MATL , 5 byte

:otYT

Hãy thử nó tại MATL trực tuyến!

Giải trình

Hãy xem xét đầu vào 4là một ví dụ.

:    % 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 byte

ÆÇ+X v

Kiểm tra nó trực tuyến! (Sử dụng -Qcờ để dễ hình dung hơn)

Giải trình

 Æ   Ç   +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

Một điều thú vị để lưu ý là vlà không một "chia hết cho 2" built-in. Thay vào đó, nó được tích hợp "chia hết cho X". Tuy nhiên, không giống như hầu hết các ngôn ngữ chơi gôn, các chức năng của Japt không có tính cố định (chúng có thể chấp nhận bất kỳ số lượng đối số đúng). Khi được đưa ra 0 đối số đúng, vgiả sử bạn muốn 2và do đó hành động chính xác như được đưa ra 2thay vì không có gì.

V , 16 , 15 byte

Ài10À­ñÙxñÎÀlD

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

Hexdump:

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

Haskell , 50 41 39 38 byte

Cảm ơn nimi và xnor vì đã giúp loại bỏ tổng cộng 9 10 byte

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

Cách khác, để có thêm một byte:

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

hoặc là:

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

Có lẽ là tối ưu, nhưng một cách tiếp cận rõ ràng, đơn giản.

APL (Dyalog) , 8 byte

~2|⍳∘.+⍳

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

Giải trình

Hãy gọi đối số n.

⍳∘.+⍳

Điều này tạo ra một ma trậ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

Sau đó 2|lấy modulo 2 của ma trận (nó vectơ) sau đó ~lấy KHÔNG của kết quả.

Toán học, 25 byte

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

JavaScript ES6, 55 54 51 46 byte

Đã lưu 1 byte nhờ @Neil

Đã lưu 2 byte nhờ @Arnauld

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

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

Điều này đầu ra như là một mảng của mảng. Phạm vi JavaScript khá khó hiểu nhưng tôi sử dụng [...Array(n)]để tạo ra một mảng kích thướcn

Võng mạc , 33 30 byte

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

Hãy thử trực tuyến! Giải thích: Giai đoạn đầu tiên chuyển đổi đầu vào thành unary bằng cách sử dụng 1s (một cách thuận tiện!) Trong khi giai đoạn thứ hai biến giá trị thành một hình vuông. Giai đoạn thứ ba đảo ngược các bit thay thế trên mỗi hàng trong khi giai đoạn cuối cùng đảo ngược các bit trên các hàng thay thế. Chỉnh sửa: Đã lưu 3 byte nhờ @MartinEnder.

MATL , 7 byte

:t!+2\~

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

Giải trình:

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

_{Lưu ý: Tôi đã bắt đầu giải quyết vấn đề này trong MATL sau khi tôi đăng thử thách.}

Brachylog , 15 byte

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

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

Giải trình

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 byte

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

Yay, công cụ phù hợp cho công việc.

05AB1E , 9 7 byte

-2 byte nhờ Emigna

LDÈD_‚è

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

Giải trình

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 byte

-3 byte nhờ 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;}

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

Hãy nhìn xem, một câu trả lời java có độ dài bán hợp lý, với rất nhiều toán tử thú vị.

lambda lấy int và trả về String. Hoạt động bằng cách sử dụng số hàng và số cột bằng cách sử dụng / và% để xác định giá trị nào sẽ là, mod 2;

Ung dung:

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

Than, 8 byte

ＵＯＮ10¶01

Hãy thử trực tuyến! Giải thích: Điều này tạm dịch là mã verbose sau (không may là deverbosifier hiện đang nối thêm một dấu phân cách không cần thiết):

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

Bình thường , 9 byte

VQm%+hdN2

Thử đi!

giải pháp 9 byte khác:

mm%+hdk2Q

Thử nó!

J , 9 byte

<0&=$&1 0

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

Toán học, 23 byte

ToeplitzMatrix@#~Mod~2&

Octave , 24 byte

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

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

Hoặc cùng chiều dài:

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

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

R , 38 37 byte

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

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

-1 byte nhờ Giuseppe

Tận dụng các quy tắc tái chế của R, trước tiên là khi tạo ma trận và thứ hai khi thêm 0: (n-1) vào ma trận đó.

Swi-Prolog, 142 byte.

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

Thử trực tuyến - http://swish.swi-prolog.org/p/BuabBPrw.pl

Nó đưa ra một danh sách lồng nhau, vì vậy các quy tắc nói:

• t() là một chuyển đổi, nó làm cho 0 -> 1 và 1 -> 0.
• r() thành công cho một hàng riêng lẻ, đó là kiểm tra đệ quy xuống một hàng mà chỉ là một hàng thay thế và số không.
• f()kiểm tra đệ quy tất cả các hàng, rằng chúng có độ dài phù hợp, chúng là các hàng hợp lệ r()và mỗi hàng bắt đầu bằng 0/1 khác nhau.
• c(N,C) nói rằng C là một trình kiểm tra hợp lệ có kích thước N nếu số lượng hàng (danh sách lồng nhau) là N và người trợ giúp f thành công.

Các trường hợp thử nghiệm:

C, 69 67 63 byte

Cảm ơn @Kevin Cruijssen đã lưu hai byte và @ceilingcat để lưu bốn byte!

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

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

QBIC , 19 byte

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

Giải trình

[:|         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 byte

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

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

PHP , 56 byte

Đầu ra dưới dạng chuỗi

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

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

PHP , 66 byte

Đầu ra là mảng 2 D

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

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

CJam , 17 byte

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

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

Trả về một danh sách (liên kết TIO có đầu ra được định dạng).

Bash + rs, 42

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

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

Cheddar , 38 byte

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

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

/// , 87 byte + đầu vào

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

Hãy thử trực tuyến! (đầu vào cho 4)

Đầu vào đơn nhất tính bằng 1s, 95 byte + đầu vào

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

Hãy thử trực tuyến! (đầu vào cho 8)

Cái này hoạt động ra sao?

• Vvà Dlà để chơi golf \/và //tương ứng.

• /*/k#/và /&1/k#&//&|//tách đầu vào thành tương đương với'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//di chuyển tất cả các ks đến /r/S/khối

• Ss chỉ được sử dụng để đệm các trường hợp kxuất hiện sau /s để chúng không bị di chuyển đi nơi khác và Ssau đó chúng bị xóa

• #s sau đó được chuyển thành r\ns

• Chuỗi ks được biến thành một 1010...chuỗi xen kẽ

• Các r\ns được biến thành 1010...\ns

• Mỗi cặp 1010...\n1010\nđược biến thành1010...\01010...;\n

• Hoặc là 0;hoặc 1;bị cắt bớt (vì 01010...chuỗi quá dài 1)

Toán học, 28 byte

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

Hàm thuần túy lấy một số nguyên dương làm đầu vào và trả về một mảng 2D. Sử dụng hàm tuần hoàn cos² (πx / 2) để tạo 1s và 0.

Để vui hơn một chút, làm thế nào về giải pháp 32 byte

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

trong đó sử dụng các vị trí của các số không tầm thường của hàm Riemann zeta.