Nehmen Sie eine positive ganze Zahl n als Eingabe und geben Sie eine n-mal-n- Schachbrettmatrix aus, die aus 1 und 0 besteht .

Die obere linke Ziffer sollte immer 1 sein .

Testfälle:

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

Eingabe- und Ausgabeformate sind optional. Die Ausgabe der Matrix als Liste von Listen wird akzeptiert.

Gelee , 4 Bytes

52 Sekunden!

+€ḶḂ

Probieren Sie es online!

MATL , 5 Bytes

:otYT

Probieren Sie es bei MATL online!

Erläuterung

Betrachten Sie die Eingabe 4als Beispiel.

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

Online testen! (Verwendet -QFlag zur einfacheren Visualisierung)

Erläuterung

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

Eine interessante Sache zu beachten ist , dass vist nicht ein „durch 2 teilbar“ eingebaut. Stattdessen ist es ein "durch X teilbares" eingebaut. Im Gegensatz zu den meisten Golfsprachen haben die Funktionen von Japt jedoch keine feste Arität (sie können eine beliebige Anzahl von richtigen Argumenten akzeptieren). Wenn 0 richtige Argumente angegeben werden, wird vdavon ausgegangen, dass Sie es wollten 2, und verhält sich genau so, als ob es 2anstelle von nichts angegeben wurde.

V , 16 , 15 Bytes

Ài10À­ñÙxñÎÀlD

Probieren Sie es online!

Hexdump:

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

Haskell , 50 41 39 38 Bytes

Vielen Dank an nimi und xnor für die Unterstützung beim Rasieren von insgesamt 9 bis 10 Bytes

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

Alternativ für ein Byte mehr:

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

oder:

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

Wahrscheinlich suboptimal, aber ein sauberer, unkomplizierter Ansatz.

APL (Dyalog) , 8 Bytes

~2|⍳∘.+⍳

Probieren Sie es online!

Erläuterung

Nennen wir das Argument n.

⍳∘.+⍳

Dies erzeugt eine Matrix

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|Nimmt dann Modulo 2 der Matrix (es vektorisiert), wonach das ~NOT des Ergebnisses genommen wird.

Mathematica, 25 Bytes

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

JavaScript ES6, 55 54 51 46 Bytes

1 Byte dank @Neil gespeichert

2 Bytes dank @Arnauld eingespart

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

Probieren Sie es online!

Dies wird als Array von Arrays ausgegeben. JavaScript-Bereiche sind ziemlich unübersichtlich, aber ich verwende [...Array(n)], die ein Array von Größe generiertn

Retina , 33-30 Bytes

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

Probieren Sie es online! Erläuterung: Die erste Stufe wandelt die Eingabe mit 1s (bequemerweise!) In unär um, während die zweite Stufe den Wert in ein Quadrat umwandelt . Die dritte Stufe invertiert abwechselnde Bits in jeder Zeile, während die letzte Stufe Bits in abwechselnden Zeilen invertiert. Bearbeiten: 3 Bytes dank @MartinEnder gespeichert.

MATL , 7 Bytes

:t!+2\~

Probieren Sie es online!

Erläuterung:

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

_{Hinweis: Ich habe mit der Lösung dieses Problems in MATL begonnen, nachdem ich die Herausforderung veröffentlicht habe.}

Brachylog , 15 Bytes

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

Probieren Sie es online!

Erläuterung

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

Ja, das richtige Werkzeug für den Job.

05AB1E , 9 7 Bytes

-2 Bytes dank Emigna

LDÈD_‚è

Probieren Sie es online!

Erläuterung

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 bis 77 Byte

-3 Bytes dank 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;}

Probieren Sie es online!

Oh, sieh mal, eine Java-Antwort von halbwegs vernünftiger Länge mit vielen lustigen Operatoren.

Lambda, das ein int nimmt und einen String zurückgibt. Verwendet die Zeilennummer und die Spaltennummer mit / und%, um zu bestimmen, welcher Wert es sein soll, 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;
}

Kohle, 8 Bytes

ＵＯＮ10¶01

Probieren Sie es online! Erläuterung: Dies übersetzt ungefähr in den folgenden ausführlichen Code (leider hängt der Deverbosifier derzeit ein unnötiges Trennzeichen an):

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

Pyth , 9 Bytes

VQm%+hdN2

Versuche dies!

Eine weitere 9-Byte-Lösung:

mm%+hdk2Q

Versuch es!

J 9 Bytes

<0&=$&1 0

Probieren Sie es online!

Mathematica, 23 Bytes

ToeplitzMatrix@#~Mod~2&

Oktave , 24 Bytes

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

Probieren Sie es online!

Oder gleich lang:

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

Probieren Sie es online!

R , 38 37 Bytes

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

Probieren Sie es online!

-1 Byte danke an Giuseppe

Nutzt die Recyclingregeln von R, zum einen beim Erstellen der Matrix und zum anderen beim Hinzufügen von 0: (n-1) zu dieser Matrix.

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

Versuchen Sie es online unter http://swish.swi-prolog.org/p/BuabBPrw.pl

Es wird eine verschachtelte Liste ausgegeben, daher lauten die Regeln:

• t() ist ein Toggle, es macht die 0 -> 1 und 1 -> 0.
• r() Erfolgreich für eine einzelne Zeile. Dies ist eine rekursive Überprüfung einer Zeile, bei der es sich nur um abwechselnde Einsen und Nullen handelt.
• f()prüft rekursiv alle Zeilen, ob sie die richtige Länge haben, ob sie gültige Zeilen sind r()und ob jede Zeile mit einem abweichenden 0/1 beginnt.
• c(N,C) sagt, dass C ein gültiges Schachbrett der Größe N ist, wenn die Anzahl der Zeilen (verschachtelte Listen) N ist und der Helfer f erfolgreich ist.

Testfälle:

C 69 67 63 Bytes

Vielen Dank an @Kevin Cruijssen für das Speichern von zwei Bytes und @ceilingcat für das Speichern von vier Bytes!

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

Probieren Sie es online!

QBIC , 19 Bytes

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

Erläuterung

[:|         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{++₁%₂}ᵐ}ᵐ

Probieren Sie es online!

PHP , 56 Bytes

Ausgabe als String

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

Probieren Sie es online!

PHP , 66 Bytes

Ausgabe als 2D-Array

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

Probieren Sie es online!

CJam , 17 Bytes

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

Probieren Sie es online!

Gibt eine Liste zurück (TIO-Link hat Ausgabe formatiert).

Bash + rs, 42

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

Probieren Sie es online aus .

Cheddar , 38 Bytes

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

Probieren Sie es online!

/// , 87 Bytes + Eingabe

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

Probieren Sie es online! (Eingabe für 4)

Unäre Eingabe in 1s, 95 Bytes + Eingabe

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

Probieren Sie es online! (Eingabe für 8)

Wie funktioniert das?

• Vund Dsind zum Golf \/und //jeweils.

• /*/k#/und /&1/k#&//&|//trennen Sie die Eingabe in das Äquivalent von'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\//Verschiebe alle ks in den /r/S/Block

• Ss werden nur verwendet, um Instanzen aufzufüllen, bei denen ks hinter /s steht, damit sie nicht an eine andere Stelle verschoben werden, und die Ss werden dann entfernt

• #Aus s wird dann r\ns

• Die Zeichenfolge von ks wird in eine alternierende 1010...Zeichenfolge umgewandelt

• Das r\ns wird zu 1010...\ns

• Aus jedem Paar 1010...\n1010\nwird1010...\01010...;\n

• Entweder 0;oder 1;abgeschnitten (weil die 01010...Zeichenfolge um 1 zu lang ist)

Mathematica, 28 Bytes

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

Reine Funktion, die eine positive Ganzzahl als Eingabe verwendet und ein 2D-Array zurückgibt. Verwendet die periodische Funktion cos² (πx / 2), um die Einsen und Nullen zu erzeugen.

Für ein bisschen mehr Spaß, wie wäre es mit der 32-Byte-Lösung

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

Dabei werden die Positionen der trivialen Nullen der Riemannschen Zeta-Funktion verwendet.