Создать матрицу шахматной доски

26

Возьмите положительное целое число 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

Форматы ввода и вывода не являются обязательными. Вывод матрицы в виде списка списков допускается.

code-golf  number  matrix 
— Стьюи Гриффин
источник
Список строк в порядке?
— xnor
Да, все в порядке.
— Стьюи Гриффин
1
— мензурка
2
Ваши примеры показывают пробелы между числами в одной строке, это необходимо, чтобы больше походить на квадрат?
— BradC
@BradC это не обязательно. Первый подход здесь действителен.
— Стьюи Гриффин

Ответы:

12

Желе , 4 байта

52 секунды!

+€ḶḂ

Попробуйте онлайн!

— Дрянная Монахиня
источник
7
"52 секунды!" как будто я к этому не привык ...
— Эрик Аутгольфер
5
Будешь ли у тебя бипер, ты носишь 24/7 для новых испытаний PPCG?
— Волшебная Урна Осьминога
@carusocomputing Те, кто имеет более быстрое подключение к Интернету, обычно являются счастливчиками, которые победят.
— Эрик Outgolfer
9

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]
— Луис Мендо
источник
7

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вместо ничего.

— ETHproductions
источник
7

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

Вероятно, неоптимальный, но чистый, прямой подход.

— Юлианский волк
источник
concat.repeatявляется cycle: n!l=take n$cycle l. Если вы идете pointfree он сохраняет еще один байт: (!)=(.cycle).take.
— Ними
Прекрасный! Я знал, что для этого есть встроенная функция, но не мог вспомнить, как меня
— Джулиан Вольф,
Я собирался предложить f n|r<-take n.cycle=r[r"10",r"01"]или подобное. но Хаскелл, кажется, делает вывод, что не тот тип r? Работает с явной типизацией f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"].
— xnor
1
@JulianWolf Haskell, кажется, испытывает затруднения при выводе полиморфных типов
— xnor
1
@zbw Я думал, что это так, но использование NoMonomorphismRestrictionне помогло. Не сделал Rank2Typesили RankNTypes. Вы знаете, что там происходит?
— xnor
5

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 матрицы (он векторизуется), после чего ~принимает НЕ результата.

— Kritixi Lithos
источник
4

JavaScript ES6, 55 54 51 46 байт

Сохранено 1 байт благодаря @Neil

Сохранено 2 байта благодаря @Arnauld

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

Попробуйте онлайн!

Это выводит в виде массива массивов. Диапазоны JavaScript довольно неудобны, но я использую, [...Array(n)]который генерирует массив размераn

— Downgoat
источник
Использование параметров индекса по-прежнему на байт короче:n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2))
— Нейл
@ Нейл, я никогда не думал использовать третий параметр в карте, спасибо!
— Вниз
@ Арнаулд спасибо! это вдохновило меня на сохранение еще 5 байтов!
— Вниз
4

Сетчатка , 33 30 байт

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

Попробуйте онлайн! Пояснение: Первая ступень преобразует входные данные в унарные, используя 1s (удобно!), А вторая ступень превращает значение в квадрат. Третья ступень инвертирует чередующиеся биты в каждой строке, в то время как последняя ступень инвертирует биты в чередующихся строках. Редактировать: 3 байта сохранены благодаря @MartinEnder.

— Нил
источник
$`1$'это просто $_.
— Мартин Эндер
@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 после того, как опубликовал задачу.

— Стьюи Гриффин
источник
Эквивалент и короче::&+o~
— Луис Мендо
1
Все еще учусь :-) Я обновлю завтра. Мне тоже понравился твой другой подход :-)
— Стьюи Гриффин
1
Это то, что я придумал тоже. И, эй, вы используете только чистый набор команд MATL, а не те надоедливые Yмодифицированные инструкции, которые использует @LuisMendo.
— Санчиз
@ Санчез Пески, а ? :-P
— Луис Мендо
3

Брахилог , 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]]
— Fatalize
источник
3

Clojure, 36 байт

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

Да, правильный инструмент для работы.

— NikoNyrh
источник
3

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
— kalsowerus
источник
Вы можете вырезать, так »как вывод списка списков в порядке, и вы также можете удалить s.
— Emigna
@ Emigna Да, спасибо!
— kalsowerus
Объяснение немного не имеет значения.
— Эрик Outgolfer
3

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;
}
— PunPun1000
источник
Вы можете удалить место, чтобы сохранить байт. Задача утверждает, что выходной формат является гибким. О, и вы можете сохранить еще два байта, изменив (i++/j+i%j)%2на i++/j+i%j&1так, чтобы вам не понадобились эти скобки. Который делает общий 1 байт короче моего решения для вложенного цикла for ( n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}), так что +1 от меня. :)
— Кевин Круйссен
@KevinCruijssen Да, я все еще ждала ответа в космосе. Я не думал о & иметь более высокий приоритет, чем% и & 1 ==% 2
— PunPun1000
2

Древесный уголь, 8 байт

ＵＯＮ10¶01

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

Oblong(InputNumber(), "10\n01");
— Нил
источник
2

R , 38 37 байт

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

Попробуйте онлайн!

-1 байт благодаря Джузеппе

Использует преимущества правил переработки R, во-первых, при создании матрицы, а во-вторых, при добавлении 0: (n-1) к этой матрице.

— user2390246
источник
Вы можете отбросить байт, избавившись от tи вместо этого построив матрицу с помощью byrow=T, то есть,(matrix(1:n,n,n,T)+1:n-1)%%2
— Джузеппе
1
outer(1:n,1:n-1,"+")%%2на несколько байт короче :)
— JAD
2

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 успешен.

Тестовые случаи: введите описание изображения здесь

— TessellatingHeckler
источник
2

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

Попробуйте онлайн!

— Steadybox
источник
Вы можете удалить пробел в printf("%d ", так как это еще один допустимый метод вывода.
— Конор О'Брайен
@ ConorO'Brien Да, спасибо.
— Steadybox
Вы можете сохранить два байта, изменив (j+++i)%2для , j+++i&1чтобы удалить эти скобки.
— Кевин Круйссен,
@ceilingcat Спасибо!
— Steadybox
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.
— steenbergh
источник
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)

— boboquack
источник
1

Mathematica, 28 байт

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

Чистая функция, принимающая положительное целое число в качестве входных данных и возвращающая 2D-массив. Использует периодическую функцию cos² (πx / 2) для генерации 1 и 0.

Для немного больше удовольствия, как насчет 32-байтового решения

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

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

— Грег Мартин
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.