# Create a checkerboard matrix

Take a positive integer n as input, and output a n-by-n checkerboard matrix consisting of 1 and 0.

The top left digit should always be 1.

Test cases:

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


Input and output formats are optional. Outputting the matrix as a list of lists is accepted.

• Is a list of strings OK? – xnor Jun 15 '17 at 17:52
• Yes, that's OK. – Stewie Griffin Jun 15 '17 at 17:53
• – beaker Jun 15 '17 at 18:51
• Your examples show spaces between numbers on the same row, is that required, so as to look more like a square? – BradC Jun 15 '17 at 19:09
• @BradC it's not required. The first approach here is valid. – Stewie Griffin Jun 15 '17 at 20:19

# Jelly, 4 bytes

52 seconds!

+€ḶḂ


Try it online!

• "52 seconds!" like I'm not used to it... – Erik the Outgolfer Jun 15 '17 at 17:35
• Do ya'll have, like, a beeper, you wear 24/7 for new PPCG challenges? – Magic Octopus Urn Jun 16 '17 at 20:43
• @carusocomputing Those who have a faster internet connection are usually the lucky ones that will win. – Erik the Outgolfer Jun 17 '17 at 14:16

# MATL, 5 bytes

:otYT


Try it at MATL online!

### Explanation

Consider input 4 as an example.

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


Test it online! (Uses -Q flag for easier visualisation)

### Explanation

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


An interesting thing to note is that v is not a "divisible by 2" built-in. Instead, it's a "divisible by X" built-in. However, unlike most golfing languages, Japt's functions do not have fixed arity (they can accept any number of right-arguments). When given 0 right-arguments, v assumes you wanted 2, and so acts exactly like it was given 2 instead of nothing.

# V, 16, 15 bytes

Ài10À­ñÙxñÎÀlD


Try it online!

Hexdump:

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


Thanks to nimi and xnor for helping to shave off a total of 9 10 bytes

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


Alternately, for one byte more:

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


or:

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


Probably suboptimal, but a clean, straightforward approach.

• concat.repeat is cycle: n!l=take n$cycle l. If you go pointfree it saves one more byte: (!)=(.cycle).take. – nimi Jun 15 '17 at 18:26 • Lovely! I knew there was a builtin for that, but couldn't remember the name for the life of me – Julian Wolf Jun 15 '17 at 18:31 • I was going to suggest f n|r<-take n.cycle=r[r"10",r"01"] or similar. but Haskell seems to infer the wrong type for r? It works with explicit typing f n|r<-take n.cycle::[a]->[a]=r[r"10",r"01"]. – xnor Jun 15 '17 at 18:59 • @JulianWolf Haskell seems to have trouble inferring polymorphic types – xnor Jun 15 '17 at 19:43 • @zbw I thought this was the case but using NoMonomorphismRestriction didn't help. Nor did Rank2Types or RankNTypes. Do you know what's going on there? – xnor Jun 16 '17 at 4:59 # APL (Dyalog), 8 bytes ~2|⍳∘.+⍳  Try it online! ### Explanation Let's call the argument n. ⍳∘.+⍳  This creates a 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  Then 2| takes modulo 2 of the matrix (it vectorises) after which ~ takes the NOT of the result. ## Mathematica, 25 bytes 1-Plus~Array~{#,#}~Mod~2&  ## JavaScript ES6, 555451 46 bytes Saved 1 byte thanks to @Neil Saved 2 bytes thanks to @Arnauld n=>[...Array(n)].map((_,i,a)=>a.map(_=>++i&1))  Try it online! This outputs as an array of arrays. JavaScript ranges are pretty unweildy but I use [...Array(n)] which generates an array of size n • It's still a byte shorter to use the index parameters: n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2)) – Neil Jun 15 '17 at 18:41 • @Neil huh, I never thought to use the third parameter in map, thanks! – Downgoat Jun 15 '17 at 18:47 • @Arnauld thanks! that inspired me to save 5 more bytes! – Downgoat Jun 15 '17 at 22:55 # Retina, 33 30 bytes .+$*
1
$_¶ 11 10 T1001¶.+¶  Try it online! Explanation: The first stage converts the input to unary using 1s (conveniently!) while the second stage turns the value into a square. The third stage inverts alternate bits on each row while the last stage inverts bits on alternate rows. Edit: Saved 3 bytes thanks to @MartinEnder. • $1$' is just $_. – Martin Ender Jun 16 '17 at 5:27
• @MartinEnder Ah, I'm unfamiliar with $_, thanks! – Neil Jun 16 '17 at 7:45 # MATL, 7 bytes :t!+2\~  Try it online! Explanation:  % 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]  Note: I started solving this in MATL after I posted the challenge. • Equivalent, and shorter: :&+o~ – Luis Mendo Jun 15 '17 at 21:25 • Still learning :-) I'll update tomorrow. I liked your other approach too :-) – Stewie Griffin Jun 15 '17 at 21:44 • This is what I came up with, too. And hey, you only use the pure MATL instruction set, not those pesky Y-modified instructions @LuisMendo uses. – Sanchises Jun 16 '17 at 21:04 • @Sanchises Pesky, huh? :-P – Luis Mendo Jun 16 '17 at 21:09 # Brachylog, 15 bytes ^₂⟦₁%₂ᵐ;?ḍ₎pᵐ.\  Try it online! ### Explanation 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, right tool for the job. # 05AB1E, 9 7 bytes -2 bytes thanks to Emigna LDÈD_‚è  Try it online! ### Explanation 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  • You can cut the » as list-of-lists output is okay and you can also remove s. – Emigna Jun 16 '17 at 7:27 • @Emigna Yep, thanks! – kalsowerus Jun 16 '17 at 10:43 • Explanation is a bit irrelevant. – Erik the Outgolfer Jun 17 '17 at 14:14 # Java (OpenJDK 8), 80 77 bytes -3 bytes thanks to 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;}  Try it online! Oh look, a semi-reasonable length java answer, with lots of fun operators. lambda which takes an int and returns a String. Works by using the row number and column number using / and % to determine which value it should be, 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; }  • You can remove the space to save a byte. The challenge states the output format is flexible. Oh, and you can save two more bytes by changing (i++/j+i%j)%2 to i++/j+i%j&1 so you won't need those parenthesis. Which make the total 1 byte shorter than my nested for-loop solution (n->{String r="";for(int i=0,j;i++<n;r+="\n")for(j=0;j<n;r+=j+++i&1);return r;}), so +1 from me. :) – Kevin Cruijssen Jun 16 '17 at 7:26 • @KevinCruijssen Yeah I was still waiting on a response on the space. I didn't think about & having higher precedence than % and &1 == %2 – PunPun1000 Jun 16 '17 at 12:02 # Charcoal, 8 bytes ＵＯＮ10¶01  Try it online! Explanation: This roughly translates to the following verbose code (unfortunately the deverbosifier is currently appending an unnecessary separator): Oblong(InputNumber(), "10\n01");  # Pyth, 9 bytes VQm%+hdN2  Try this! another 9 byte solution: mm%+hdk2Q  Try it! # J, 9 bytes <0&=$&1 0


Try it online!

# Mathematica, 23 bytes

ToeplitzMatrix@#~Mod~2&


# Octave, 24 bytes

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


Try it online!

Or the same length:

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


Try it online!

# R, 38 37 bytes

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


Try it online!

-1 byte thanks to Giuseppe

Takes advantage of R's recycling rules, firstly when creating the matrix, and secondly when adding 0:(n-1) to that matrix.

• You can drop a byte by getting rid of the t and instead constructing the matrix with byrow=T, i.e., (matrix(1:n,n,n,T)+1:n-1)%%2 – Giuseppe Jun 16 '17 at 14:12
• outer(1:n,1:n-1,"+")%%2 is quite a few bytes shorter :) – JAD Jun 23 '17 at 12:01

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


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

It outputs a nested list, so the rules say:

• t() is a toggle, it makes the 0 -> 1 and 1 -> 0.
• r() succeeds for an individual row, which is a recursive check down a row that it is alternate ones and zeros only.
• f() recursively checks all the rows, that they are the right length, that they are valid rows with r() and that each row starts with a differing 0/1.
• c(N,C) says that C is a valid checkerboard of size N if the number of rows (nested lists) is N, and the helper f succeeds.

Test Cases:

# C, 6967 63 bytes

Thanks to @Kevin Cruijssen for saving two bytes and @ceilingcat for saving four bytes!

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


Try it online!

• You can remove the space in printf("%d ", since that's another valid method of output. – Conor O'Brien Jun 15 '17 at 21:09
• @ConorO'Brien Yeah, thanks. – Steadybox Jun 15 '17 at 21:15
• You can save two bytes by changing (j+++i)%2 to j+++i&1 to remove those parenthesis. – Kevin Cruijssen Jun 16 '17 at 7:31
• @ceilingcat Thanks! – Steadybox Sep 8 '17 at 0:02

# QBIC, 19 bytes

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


## Explanation

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


Try it online!

# PHP, 56 bytes

Output as string

for(;$i<$argn**2;)echo++$i%2^$n&1,$i%$argn?"":"
".!++$n;  Try it online! # PHP, 66 bytes Output as 2 D array for(;$i<$argn**2;$i%$argn?:++$n)$r[+$n][]=++$i%2^$n&1;print_r($r);  Try it online! # CJam, 17 bytes {_[__AAb*<_:!]*<}  Try it online! Returns a list (TIO link has formatted output). # Bash + rs, 42 eval echo \$[~{1..$1}+{1..$1}\&1]|rs $1$1


# Cheddar, 38 bytes

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


Try it online!

# ///, 87 bytes + input

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


Try it online! (input for 4)

## Unary input in 1s, 95 bytes + input

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


Try it online! (input for 8)

### How does this work?

• V and D are to golf \/ and // respectively.

• /*/k#/ and /&1/k#&//&|// separate the input into the equivalent of 'k#'*len(input())

• /#k//k#//&k/k&//\/k/k\// move all the ks to the /r/S/ block

• Ss are just used to pad instances where ks come after /s so that they don't get moved elsewhere, and the Ss are then removed

• #s are then turned into r\ns

• The string of ks is turned into an alternating 1010... string

• The r\ns are turned into 1010...\ns

• Every pair of 1010...\n1010\n is turned into 1010...\01010...;\n

• Either 0; or 1; are trimmed off (because the 01010... string is too long by 1)

# Mathematica, 28 bytes

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


Pure function taking a positive integer as input and returning a 2D array. Uses the periodic function cos²(πx/2) to generate the 1s and 0s.

For a little more fun, how about the 32-byte solution

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


which uses the locations of the trivial zeros of the Riemann zeta function.