양수 인출 N을 입력으로하고 출력 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]

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

흥미로운 점 은 "2로 나눌 수있는"내장 기능 v이 아니라는 것입니다. 대신 "X로 나눌 수있는"내장 기능입니다. 그러나 대부분의 골프 언어와 달리 Japt의 기능에는 고정 된 특성이 없습니다 (다수의 오른쪽 인수를 사용할 수 있음). 오른쪽 인수가 0이면, v당신이 원한다고 가정 2하고, 2아무것도 대신 주어진 것과 똑같이 행동합니다 .

V , 16 , 15 바이트

Ài10À­ñÙxñÎÀlD

온라인으로 사용해보십시오!

16 진 덤프 :

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

하스켈 , 50 41 39 38 바이트

총 9 10 바이트 를 줄이는 데 도움을 준 nimi와 xnor에게 감사 합니다.

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

또는 1 바이트 이상 :

(!)=(.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를 취하고 (벡터화) ~결과의 NOT 을 취합니다.

Mathematica, 25 바이트

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

자바 스크립트 ES6, 55 54 51 46 바이트

@Neil 덕분에 1 바이트 절약

@Arnauld 덕분에 2 바이트 절약

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

온라인으로 사용해보십시오!

배열의 배열로 출력됩니다. 자바 스크립트 범위는 꽤 좋지 않지만 [...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]]

클로저, 36 바이트

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

예, 작업에 적합한 도구입니다.

05AB1E , 9 7 바이트

Emigna 덕분에 -2 바이트

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

자바 (OpenJDK 8) , 80 77 바이트

Kevin Cruijssen 덕분에 -3 바이트

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를 가져 와서 String을 반환합니다. /와 %를 사용하여 행 번호와 열 번호를 사용하여 값을 결정합니다. 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

온라인으로 사용해보십시오! 설명 : 이것은 대략 다음과 같은 자세한 코드로 변환됩니다 (불행하게도 디버 보시 파이어는 현재 불필요한 구분 기호를 추가하고 있습니다) :

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

Pyth , 9 바이트

VQm%+hdN2

이 시도!

다른 9 바이트 솔루션 :

mm%+hdk2Q

시도 해봐!

J , 9 바이트

<0&=$&1 0

온라인으로 사용해보십시오!

매스 매 티카, 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 바이트

행렬을 만들 때와 둘째로 해당 행렬에 0 : (n-1)을 추가 할 때 R의 재활용 규칙을 이용합니다.

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() 개별 행에 대해 성공합니다. 이는 행이 1과 0 인 행만 재귀 검사합니다.
• f()모든 행을 재귀 적으로 검사합니다. 올바른 행인지, 유효한 행 r()인지, 각 행이 다른 0/1로 시작하는지 확인합니다.
• c(N,C) 행 수 (중첩 목록)가 N이고 도우미 f가 성공하면 C는 N 크기의 유효한 바둑판이라고 말합니다.

테스트 사례 :

C, 69 67 63 바이트

2 바이트를 저장 한 @Kevin Cruijssen과 4 바이트를 저장 한 @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 바이트

2D 배열로 출력

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

온라인으로 사용해보십시오!

CJam , 17 바이트

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

온라인으로 사용해보십시오!

목록을 리턴합니다 (TIO 링크는 출력을 형식화했습니다).

배쉬 + rs, 42

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

온라인으로 사용해보십시오 .

체다 , 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/블록으로 이동

• S는 ks 다음에 오는 인스턴스를 채우는 데 사용되어 /다른 곳으로 이동하지 않고 Ss를 제거합니다.

• #그런 다음 r\ns 로 바뀝니다.

• ks 의 문자열이 번갈아가는 1010...문자열 로 바뀝니다.

• r\n들로 설정되어 1010...\n의

• 의 모든 쌍 1010...\n1010\n으로 설정되어1010...\01010...;\n

• 하나 0;또는 1;합니다 (때문에 꺼립니다 01010...문자열이 1 너무 깁니다)

수학, 28 바이트

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

양의 정수를 입력으로 받아 2D 배열을 반환하는 순수 함수. 주기 함수 cos² (πx / 2)를 사용하여 1과 0을 생성합니다.

좀 더 재미있게, 32 바이트 솔루션은 어떻습니까?

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

이것은 리만 제타 함수의 사소한 제로의 위치를 ​​사용합니다.