Pegue um número inteiro positivo n como entrada e produza uma matriz quadriculado n por n que consiste em 1 e 0 .

O dígito superior esquerdo deve sempre ser 1 .

Casos de teste:

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

Os formatos de entrada e saída são opcionais. A saída da matriz como uma lista de listas é aceita.

Gelatina , 4 bytes

52 segundos!

+€ḶḂ

Experimente online!

MATL , 5 bytes

:otYT

Experimente no MATL online!

Explicação

Considere a entrada 4como um exemplo.

:    % 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]

Japonês , 6 bytes

ÆÇ+X v

Teste online! (Usa -Qsinalizador para facilitar a visualização)

Explicação

 Æ   Ç   +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

Uma coisa interessante a notar é que nãov é um "divisível por 2" embutido. Em vez disso, é um "divisível por X" embutido. No entanto, diferentemente da maioria dos idiomas do golfe, as funções de Japt não têm aridade fixa (elas podem aceitar qualquer número de argumentos corretos). Quando recebe 0 argumentos corretos, assume que você deseja e age exatamente como foi dado em vez de nada.v22

V , 16 , 15 bytes

Ài10À­ñÙxñÎÀlD

Experimente online!

Hexdump:

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

Haskell , 50 41 39 38 bytes

Agradecimentos a nimi e xnor por ajudar a remover um total de 9 10 bytes

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

Como alternativa, por mais um byte:

(!)=(.cycle).take
f n=n![n!"10",n!"01"]

ou:

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

Provavelmente abaixo do ideal, mas uma abordagem limpa e direta.

APL (Dyalog) , 8 bytes

~2|⍳∘.+⍳

Experimente online!

Explicação

Vamos chamar o argumento n.

⍳∘.+⍳

Isso cria uma matriz

1+1 1+2 1+2 .. 1+n
2+1 2+2 2+3 .. 2+n
...
n+1 n+2 n+3 .. n+n

Então 2|pega o módulo 2 da matriz (vetoriza) e depois ~pega o NOT do resultado.

Mathematica, 25 bytes

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

JavaScript ES6, 55 54 51 46 bytes

Guardado 1 byte graças a @Neil

Guardado 2 bytes graças a @Arnauld

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

Experimente online!

Isso gera como uma matriz de matrizes. Os intervalos de JavaScript são bastante indecisos, mas eu uso o [...Array(n)]que gera uma matriz de tamanhon

Retina , 33 30 bytes

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

Experimente online! Explicação: O primeiro estágio converte a entrada em unário usando 1s (convenientemente!) Enquanto o segundo estágio transforma o valor em um quadrado. O terceiro estágio inverte bits alternativos em cada linha, enquanto o último estágio inverte bits em linhas alternativas. Editar: salvou 3 bytes graças a @MartinEnder.

MATL , 7 bytes

:t!+2\~

Experimente online!

Explicação:

         % 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]

_{Nota: comecei a resolver isso no MATL depois de postar o desafio.}

Braquilog , 15 bytes

^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\

Experimente online!

Explicação

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 bytes

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

Sim, ferramenta certa para o trabalho.

05AB1E , 9 7 bytes

-2 bytes graças a Emigna

LDÈD_‚è

Experimente online!

Explicação

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 bytes

-3 bytes graças a 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;}

Experimente online!

Oh, olha, uma resposta java de comprimento semi-razoável, com muitos operadores divertidos.

lambda que recebe um int e retorna uma String. Funciona usando o número da linha e o número da coluna usando / e% para determinar qual valor deve ser, 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;
}

Carvão, 8 bytes

ＵＯＮ10¶01

Experimente online! Explicação: Isso se traduz aproximadamente no código detalhado a seguir (infelizmente, atualmente o deverbosifier está anexando um separador desnecessário):

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

Pitão , 9 bytes

VQm%+hdN2

Tente isso!

outra solução de 9 bytes:

mm%+hdk2Q

Tente!

J , 9 bytes

<0&=$&1 0

Experimente online!

Mathematica, 23 bytes

ToeplitzMatrix@#~Mod~2&

Oitava , 24 bytes

@(n)~mod((a=(1:n))+a',2)

Experimente online!

Ou o mesmo comprimento:

@(n)mod(toeplitz(1:n),2)

Experimente online!

R , 38 bytes 37

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

Experimente online!

-1 byte graças a Giuseppe

Aproveita as regras de reciclagem de R, primeiro ao criar a matriz e depois ao adicionar 0: (n-1) a essa matriz.

Swi-Prolog, 142 bytes.

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).

Experimente online - http://swish.swi-prolog.org/p/BuabBPrw.pl

Como gera uma lista aninhada, as regras dizem:

• t() é uma alternância, cria 0 -> 1 e 1 -> 0.
• r() obtém êxito em uma linha individual, que é uma verificação recursiva em uma linha, indicando que são apenas zeros e uns alternativos.
• f()verifica recursivamente todas as linhas, se têm o comprimento certo, se são linhas válidas r()e se cada linha começa com um 0/1 diferente.
• c(N,C) diz que C é um tabuleiro de damas válido do tamanho N se o número de linhas (listas aninhadas) for N e o ajudante f tiver êxito.

Casos de teste:

C, 69 67 63 bytes

Agradecemos a @Kevin Cruijssen por salvar dois bytes e @ceilingcat por salvar quatro bytes!

i,j;f(n){for(i=n;i--;puts(""))for(j=n;j;)printf("%d",j--+i&1);}

Experimente online!

QBIC , 19 bytes

[:|?[b|?(a+c+1)%2';

Explicação

[:|         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.

Braquilog , 19 bytes

⟦₁Rg;Rz{z{++₁%₂}ᵐ}ᵐ

Experimente online!

PHP , 56 bytes

Saída como sequência

for(;$i<$argn**2;)echo++$i%2^$n&1,$i%$argn?"":"
".!++$n;

Experimente online!

PHP , 66 bytes

Saída como matriz 2 D

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

Experimente online!

CJam , 17 bytes

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

Experimente online!

Retorna uma lista (o link TIO formatou a saída).

Bash + rs, 42

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

Experimente online .

Queijo Cheddar , 38 bytes

n->(|>n).map(i->(|>n).map(j->i+j+1&1))

Experimente online!

/// , 87 bytes + entrada

/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]

Experimente online! (entrada para 4)

Entrada unária em 1s, 95 bytes + entrada

/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]|

Experimente online! (entrada para 8)

Como é que isso funciona?

• Ve Dsão para o golfe \/e, //respectivamente.

• /*/k#/e /&1/k#&//&|//separar a entrada no equivalente a'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//mover todos os ks para o /r/S/bloco

• Ss são usados ​​apenas para proteger instâncias em que ks vêm depois de /s para que não sejam movidos para outro lugar e os Ss são removidos

• #s são então transformados em r\ns

• A sequência de ks é transformada em uma 1010...sequência alternada

• Os r\ns são transformados em 1010...\ns

• Cada par de 1010...\n1010\né transformado em1010...\01010...;\n

• Quer 0;ou 1;são cortados fora (porque a 01010...cadeia é muito longa por 1)

Mathematica, 28 bytes

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

Função pura, recebendo um número inteiro positivo como entrada e retornando uma matriz 2D. Usa a função periódica cos² (πx / 2) para gerar os 1s e 0s.

Para um pouco mais de diversão, que tal a solução de 32 bytes

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

que usa os locais dos zeros triviais da função Riemann zeta.