Возьмите положительное целое число n в качестве входных данных и выведите матрицу n-by-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

Интересно отметить, что 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 (Дьялог) , 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 после того, как опубликовал задачу.}

Брахилог , 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 байта благодаря Кевину Круйссену

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 и возвращает строку. Работает, используя номер строки и номер столбца, используя / и%, чтобы определить, какое значение это должно быть, мод 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

Попробуйте онлайн! Объяснение: Это примерно соответствует следующему подробному коду (к сожалению, в настоящее время девербозификатор добавляет ненужный разделитель):

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 байт благодаря Джузеппе

Использует преимущества правил переработки 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 имеет форматированный вывод).

Баш + рс, 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)

Унарный ввод в 1с, 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 затем удаляются

• #с затем превращаются в r\nс

• Строка ks превращается в переменную 1010...строку

• С r\nпревращаются в 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~{#,#}&

который использует местоположения тривиальных нулей дзета-функции Римана.