ใช้เป็นจำนวนเต็มบวกnเป็น input และเอาท์พุทn โดย nเมทริกซ์หมากรุกประกอบด้วย1และ0

ตัวเลขบนซ้ายควรเป็น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]

Japtap , 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 ไม่ได้มี arity คงที่ (พวกเขาสามารถยอมรับจำนวนอาร์กิวเมนต์ที่เหมาะสมใด ๆ ) เมื่อได้รับข้อโต้แย้งที่ถูกต้อง 0 ข้อvสันนิษฐานว่าคุณต้องการ2และทำหน้าที่เหมือนกับที่ได้รับ2แทนที่จะเป็นอะไร

V , 16 , 15 ไบต์

Ài10À­ñÙxñÎÀlD

ลองออนไลน์!

hexdump:

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 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณ @Neil

บันทึก 2 ไบต์ขอบคุณ @Arnauld

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

ลองออนไลน์!

เอาต์พุตนี้เป็นอาร์เรย์ของอาร์เรย์ ช่วง JavaScript ค่อนข้างไม่สวย แต่ฉันใช้[...Array(n)]ซึ่งสร้างอาร์เรย์ขนาดn

เรติน่า , 33 30 ไบต์

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

ลองออนไลน์! คำอธิบาย: สเตจแรกแปลงอินพุตเป็นเอกภาพโดยใช้1s (สะดวก!) ในขณะที่สเตจที่สองเปลี่ยนค่าเป็นสแควร์ ขั้นตอนที่สามสลับบิตทางเลือกในแต่ละแถวในขณะที่ขั้นตอนสุดท้ายสลับบิตในแถวอื่น แก้ไข: บันทึกแล้ว 3 ไบต์ด้วย @MartinEnder

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

ลองออนไลน์!

โอ้คำตอบของจาวาความยาวกึ่งมีเหตุผลมีผู้ให้บริการความสนุกสนานมากมาย

แลมบ์ดาซึ่งรับค่า int และส่งคืนสตริง ทำงานโดยใช้หมายเลขแถวและหมายเลขคอลัมน์โดยใช้ / และ% เพื่อกำหนดค่าที่ควรจะเป็น mod 2;

Ungolfed:

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

ลองออนไลน์! คำอธิบาย: สิ่งนี้แปลโดยประมาณเป็นรหัส verbose ต่อไปนี้ (น่าเสียดายที่ 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() ประสบความสำเร็จสำหรับแต่ละแถวซึ่งเป็น recursive ตรวจสอบแถวที่มันเป็นคนอื่นและศูนย์เท่านั้น
• f()ตรวจสอบแถวทั้งหมดซ้ำ ๆ ว่าเป็นความยาวที่ถูกต้องว่าเป็นแถวที่ถูกต้องr()และแต่ละแถวเริ่มต้นด้วย 0/1
• c(N,C) บอกว่า C เป็นกระดานตรวจสอบที่ถูกต้องที่มีขนาด N หากจำนวนแถว (รายการที่ซ้อนกัน) คือ 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 ใช้ในการทำอินสแตนซ์ที่kมาหลังจาก/s เพื่อไม่ให้ถูกย้ายไปที่อื่นและSs จะถูกลบออก

• #จากนั้นจะเปลี่ยนเป็นr\ns

• สตริงของks กลายเป็น1010...สตริงสำรอง

• r\ns จะกลายเป็น1010...\ns

• ทุกคู่1010...\n1010\nกลายเป็น1010...\01010...;\n

• อย่างใดอย่างหนึ่ง0;หรือ1;ถูกตัดออก (เพราะ01010...สายยาวเกินไป 1)

Mathematica ขนาด 28 ไบต์

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

ฟังก์ชั่น Pure รับจำนวนเต็มบวกเป็นอินพุตและส่งกลับอาร์เรย์ 2D ใช้ฟังก์ชั่นเป็นระยะ ๆ cos² (πx / 2) เพื่อสร้าง 1s และ 0s

เพื่อความสนุกสนานอีกเล็กน้อยวิธีแก้ปัญหาแบบ 32 ไบต์

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

ซึ่งใช้ตำแหน่งของเลขศูนย์เล็ก ๆ ของฟังก์ชันซีตารีมันน์