Prenez un entier positif n en entrée et sortez une matrice de damier n par n composée de 1 et 0 .

Le chiffre en haut à gauche doit toujours être 1 .

Cas de test:

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

Les formats d'entrée et de sortie sont facultatifs. La sortie de la matrice sous forme de liste de listes est acceptée.

Gelée , 4 octets

52 secondes!

+€ḶḂ

Essayez-le en ligne!

MATL , 5 octets

:otYT

Essayez-le sur MATL en ligne!

Explication

Considérez la saisie 4comme exemple.

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

ÆÇ+X v

Testez-le en ligne! (Utilise le -Qdrapeau pour une visualisation plus facile)

Explication

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

Une chose intéressante à noter est que ce vn'est pas un "divisible par 2" intégré. Au lieu de cela, c'est un "divisible par X" intégré. Cependant, contrairement à la plupart des langages de golf, les fonctions de Japt n'ont pas d'arité fixe (elles peuvent accepter n'importe quel nombre d'arguments de droite). Lorsque 0 argument de droite est donné, vsuppose que vous vouliez 2, et agit donc exactement comme il a été donné 2au lieu de rien.

V , 16 , 15 octets

Ài10À­ñÙxñÎÀlD

Essayez-le en ligne!

Hexdump:

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

Haskell , 50 41 39 38 octets

Merci à nimi et xnor d'avoir aidé à raser un total de 9 10 octets

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

Alternativement, pour un octet de plus:

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

ou:

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

Probablement sous-optimal, mais une approche claire et simple.

APL (Dyalog) , 8 octets

~2|⍳∘.+⍳

Essayez-le en ligne!

Explication

Appelons l'argument n.

⍳∘.+⍳

Cela crée une matrice

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

Prend ensuite le 2|modulo 2 de la matrice (il vectorise) après quoi ~prend le NON du résultat.

Mathematica, 25 octets

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

JavaScript ES6, 55 54 51 46 octets

1 octet enregistré grâce à @Neil

Sauvegardé 2 octets grâce à @Arnauld

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

Essayez-le en ligne!

Cela sort comme un tableau de tableaux. Les plages JavaScript sont assez peu pratiques, mais j'utilise [...Array(n)]ce qui génère un tableau de taillen

Rétine , 33 30 octets

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

Essayez-le en ligne! Explication: Le premier étage convertit l'entrée en unaire à l'aide de 1s (commodément!) Tandis que le deuxième étage transforme la valeur en carré. La troisième étape inverse les bits alternés sur chaque ligne tandis que la dernière étape inverse les bits sur les lignes alternatives. Edit: sauvé 3 octets grâce à @MartinEnder.

MATL , 7 octets

:t!+2\~

Essayez-le en ligne!

Explication:

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

_{Remarque: J'ai commencé à résoudre ce problème dans MATL après avoir posté le défi.}

Brachylog , 15 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Oui, le bon outil pour le travail.

05AB1E , 9 7 octets

-2 octets grâce à Emigna

LDÈD_‚è

Essayez-le en ligne!

Explication

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 octets

-3 octets grâce à 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;}

Essayez-le en ligne!

Oh regardez, une réponse java de longueur semi-raisonnable, avec beaucoup d'opérateurs amusants.

lambda qui prend un entier et renvoie une chaîne. Fonctionne en utilisant le numéro de ligne et le numéro de colonne en utilisant / et% pour déterminer quelle valeur il doit être, mod 2;

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

Fusain, 8 octets

ＵＯＮ10¶01

Essayez-le en ligne! Explication: Cela se traduit approximativement par le code détaillé suivant (malheureusement, le déverbosificateur ajoute actuellement un séparateur inutile):

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

Pyth , 9 octets

VQm%+hdN2

Essaye ça!

une autre solution de 9 octets:

mm%+hdk2Q

Essayez!

J , 9 octets

<0&=$&1 0

Essayez-le en ligne!

Mathematica, 23 octets

ToeplitzMatrix@#~Mod~2&

Octave , 24 octets

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

Essayez-le en ligne!

Ou la même longueur:

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

Essayez-le en ligne!

R , 38 37 octets

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

Essayez-le en ligne!

-1 octet grâce à Giuseppe

Profite des règles de recyclage de R, d'une part lors de la création de la matrice, et d'autre part lors de l'ajout de 0: (n-1) à cette matrice.

Swi-Prolog, 142 octets.

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

Essayez en ligne - http://swish.swi-prolog.org/p/BuabBPrw.pl

Il génère une liste imbriquée, donc les règles disent:

• t() est une bascule, elle fait 0 -> 1 et 1 -> 0.
• r() réussit pour une ligne individuelle, qui est une vérification récursive sur une ligne qu'il s'agit uniquement de uns et de zéros alternatifs.
• f()vérifie récursivement toutes les lignes, qu'elles sont de la bonne longueur, qu'elles sont des lignes valides avec r()et que chaque ligne commence par un 0/1 différent.
• c(N,C) indique que C est un damier valide de taille N si le nombre de lignes (listes imbriquées) est N, et que l'aide f réussit.

Cas de test:

C, 69 67 63 octets

Merci à @Kevin Cruijssen pour avoir sauvé deux octets et @ceilingcat pour avoir sauvé quatre octets!

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

Essayez-le en ligne!

QBIC , 19 octets

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

Explication

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

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

Essayez-le en ligne!

PHP , 56 octets

Sortie sous forme de chaîne

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

Essayez-le en ligne!

PHP , 66 octets

Sortie en réseau 2 D

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

Essayez-le en ligne!

CJam , 17 octets

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

Essayez-le en ligne!

Renvoie une liste (le lien TIO a une sortie formatée).

Bash + rs, 42

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

Essayez-le en ligne .

Cheddar , 38 octets

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

Essayez-le en ligne!

/// , 87 octets + entrée

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

Essayez-le en ligne!(entrée pour 4)

Entrée unaire en 1s, 95 octets + entrée

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

Essayez-le en ligne!(entrée pour 8)

Comment cela marche-t-il?

• Vet Dsont au golf \/et //respectivement.

• /*/k#/et /&1/k#&//&|//séparez l'entrée en l'équivalent de'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//déplacer tous les ks vers le /r/S/bloc

• Sles s sont juste utilisés pour remplir les instances où ks viennent après /s afin qu'ils ne soient pas déplacés ailleurs, et les Ss sont ensuite supprimés

• #s sont ensuite transformés en r\ns

• La chaîne de ks est transformée en une 1010...chaîne alternée

• Les r\ns sont transformés en 1010...\ns

• Chaque paire 1010...\n1010\nest transformée en1010...\01010...;\n

• Soit 0;ou 1;sont coupés (car la 01010...chaîne est trop longue de 1)

Mathematica, 28 octets

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

Fonction pure prenant un entier positif en entrée et renvoyant un tableau 2D. Utilise la fonction périodique cos² (πx / 2) pour générer les 1 et les 0.

Pour un peu plus de plaisir, que diriez-vous de la solution de 32 octets

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

qui utilise les emplacements des zéros triviaux de la fonction zêta de Riemann.