Tome un entero positivo n como entrada y genere una matriz de tablero de ajedrez n por n que consta de 1 y 0 .

El dígito superior izquierdo siempre debe ser 1 .

Casos de prueba:

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

Los formatos de entrada y salida son opcionales. Se acepta la salida de la matriz como una lista de listas.

Jalea , 4 bytes

52 segundos!

+€ḶḂ

Pruébalo en línea!

MATL , 5 bytes

:otYT

¡Pruébelo en MATL en línea!

Explicación

Considere la entrada 4como un ejemplo.

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

ÆÇ+X v

¡Pruébalo en línea! (Utiliza la -Qbandera para una visualización más fácil)

Explicación

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

Una cosa interesante a tener en cuenta es que nov es un "divisible por 2" incorporado. En cambio, es un "divisible por X" incorporado. Sin embargo, a diferencia de la mayoría de los lenguajes de golf, las funciones de Japt no tienen aridad fija (pueden aceptar cualquier número de argumentos correctos). Cuando se le dan 0 argumentos correctos, se supone que desea , y por lo tanto actúa exactamente como se dio en lugar de nada.v22

V , 16 , 15 bytes

Ài10À­ñÙxñÎÀlD

Pruébalo en línea!

Hexdump:

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

Haskell , 50 41 39 38 bytes

Gracias a nimi y xnor por ayudarnos a recortar un total de 9 10 bytes

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

Alternativamente, para un byte más:

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

o:

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

Probablemente subóptimo, pero un enfoque limpio y directo.

APL (Dyalog) , 8 bytes

~2|⍳∘.+⍳

Pruébalo en línea!

Explicación

Llamemos al argumento n.

⍳∘.+⍳

Esto crea una 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

Luego 2|toma el módulo 2 de la matriz (se vectoriza) después de lo cual ~toma el NOT del resultado.

Mathematica, 25 bytes

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

JavaScript ES6, 55 54 51 46 bytes

Guardado 1 byte gracias a @Neil

Guardado 2 bytes gracias a @Arnauld

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

Pruébalo en línea!

Esto se genera como una matriz de matrices. Los rangos de JavaScript son bastante extraños, pero yo uso los [...Array(n)]que generan una variedad de tamañosn

Retina , 33 30 bytes

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

Pruébalo en línea! Explicación: La primera etapa convierte la entrada a unaria usando 1s (¡convenientemente!) Mientras que la segunda etapa convierte el valor en un cuadrado. La tercera etapa invierte bits alternativos en cada fila, mientras que la última etapa invierte bits en filas alternativas. Editar: Guardado 3 bytes gracias a @MartinEnder.

MATL , 7 bytes

:t!+2\~

Pruébalo en línea!

Explicación:

         % 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: Comencé a resolver esto en MATL después de publicar el desafío.}

Brachylog , 15 bytes

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

Pruébalo en línea!

Explicación

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

Yay, la herramienta adecuada para el trabajo.

05AB1E , 9 7 bytes

-2 bytes gracias a Emigna

LDÈD_‚è

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Oh, mira, una respuesta Java de longitud semi razonable, con muchos operadores divertidos.

lambda que toma un int y devuelve una cadena. Funciona usando el número de fila y el número de columna usando / y% para determinar qué valor debería ser, mod 2;

Sin golf:

j->{
    String s="1";
    for(int i=1; i<j*j; s+= i++/j + i%j&1 )
        s+= 1>i%j ? "\n" : "";
    return s;
}

Carbón de leña, 8 bytes

ＵＯＮ10¶01

Pruébalo en línea! Explicación: Esto se traduce aproximadamente al siguiente código detallado (desafortunadamente, el desverbosificador está agregando un separador innecesario):

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

Pyth , 9 bytes

VQm%+hdN2

¡Prueba esto!

otra solución de 9 bytes:

mm%+hdk2Q

¡Intentalo!

J , 9 bytes

<0&=$&1 0

Pruébalo en línea!

Mathematica, 23 bytes

ToeplitzMatrix@#~Mod~2&

Octava , 24 bytes

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

Pruébalo en línea!

O la misma longitud:

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

Pruébalo en línea!

R , 38 37 bytes

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

Pruébalo en línea!

-1 byte gracias a Giuseppe

Aprovecha las reglas de reciclaje de R, en primer lugar al crear la matriz, y en segundo lugar al agregar 0: (n-1) a esa 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).

Pruebe en línea: http://swish.swi-prolog.org/p/BuabBPrw.pl

Produce una lista anidada, por lo que las reglas dicen:

• t() es una palanca, hace que el 0 -> 1 y 1 -> 0.
• r() tiene éxito para una fila individual, que es un chequeo recursivo en una fila de que solo son alternativas y ceros.
• f()verifica recursivamente todas las filas, que tienen la longitud correcta, que son filas válidas r()y que cada fila comienza con un 0/1 diferente.
• c(N,C) dice que C es un tablero de damas válido de tamaño N si el número de filas (listas anidadas) es N, y el ayudante f tiene éxito.

Casos de prueba:

C, 69 67 63 bytes

¡Gracias a @Kevin Cruijssen por guardar dos bytes y @ceilingcat por guardar cuatro bytes!

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

Pruébalo en línea!

QBIC , 19 bytes

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

Explicación

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

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

Pruébalo en línea!

PHP , 56 bytes

Salida como cadena

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

Pruébalo en línea!

PHP , 66 bytes

Salida como matriz 2 D

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

Pruébalo en línea!

CJam , 17 bytes

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

Pruébalo en línea!

Devuelve una lista (el enlace TIO tiene formato de salida).

Bash + rs, 42

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

Pruébalo en línea .

Cheddar , 38 bytes

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

Pruébalo en línea!

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

Pruébalo en línea! (entrada para 4)

Entrada unaria en 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]|

Pruébalo en línea! (entrada para 8)

¿Como funciona esto?

• Vy Dson para golf \/y //respectivamente.

• /*/k#/y /&1/k#&//&|//separe la entrada en el equivalente de'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//mover todos los ks al /r/S/bloque

• Ss solo se utilizan para rellenar instancias donde ks vienen después de /s para que no se muevan a otro lugar, y Sluego se eliminan

• #s luego se convierten en r\ns

• La cadena de ks se convierte en una 1010...cadena alterna

• Los r\ns se convierten en 1010...\ns

• Cada par de 1010...\n1010\nse convierte en1010...\01010...;\n

• Ya sea 0;o 1;están recortados (porque la 01010...cadena es demasiado larga en 1)

Mathematica, 28 bytes

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

Función pura que toma un entero positivo como entrada y devuelve una matriz 2D. Utiliza la función periódica cos² (πx / 2) para generar los 1s y 0s.

Para un poco más de diversión, ¿qué tal la solución de 32 bytes?

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

que utiliza las ubicaciones de los ceros triviales de la función zeta de Riemann.