Візьміть додаткове ціле число n як вхідне та виведіть матрицю n-by-n checkboard, що складається з 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

Цікава річ, що vце не вбудований "ділиться на 2". Натомість це вбудований "подільний на X". Однак, на відміну від більшості мов для гольфу, функції Japt не мають фіксованої суворості (вони можуть приймати будь-яку кількість правильних аргументів). Коли вам дано 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 матриці (вона векторизується), після чого ~приймає НЕ результату.

Математика, 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 після того, як опублікував виклик.}

Брахілог , 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 байти завдяки Еміньї

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. Працює, використовуючи номер рядка та номер стовпця, використовуючи / та%, щоб визначити, яке значення воно повинно бути, мод 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 байт завдяки Джузеппе

Скористається правилами утилізації 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) говорить, що 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.

Брахілог , 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

Спробуйте в Інтернеті .

Чеддар , 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)

Математика, 28 байт

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

Чиста функція, яка приймає додаткове ціле число як вхід і повертає 2D масив. Використовує періодичну функцію cos² (πx / 2) для генерування 1s і 0s.

Для трохи веселіше, як щодо 32-байтового рішення

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

який використовує місця розташування тривіальних нулів zeta функції Рімана.