26
\$\begingroup\$

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.

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

47 Answers 47

12
\$\begingroup\$

Jelly, 4 bytes

52 seconds!

+€ḶḂ

Try it online!

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

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]
\$\endgroup\$
7
\$\begingroup\$

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.

\$\endgroup\$
7
\$\begingroup\$

V, 16, 15 bytes

Ài10À­ñÙxñÎÀlD

Try it online!

Hexdump:

00000000: c069 3130 1bc0 adf1 d978 f1ce c06c 44    .i10.....x...lD
\$\endgroup\$
7
\$\begingroup\$

Haskell, 50 41 39 38 bytes

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.

\$\endgroup\$
  • \$\begingroup\$ concat.repeat is cycle: n!l=take n$cycle l. If you go pointfree it saves one more byte: (!)=(.cycle).take. \$\endgroup\$ – nimi Jun 15 '17 at 18:26
  • \$\begingroup\$ Lovely! I knew there was a builtin for that, but couldn't remember the name for the life of me \$\endgroup\$ – Julian Wolf Jun 15 '17 at 18:31
  • \$\begingroup\$ 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"]. \$\endgroup\$ – xnor Jun 15 '17 at 18:59
  • 1
    \$\begingroup\$ @JulianWolf Haskell seems to have trouble inferring polymorphic types \$\endgroup\$ – xnor Jun 15 '17 at 19:43
  • 1
    \$\begingroup\$ @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? \$\endgroup\$ – xnor Jun 16 '17 at 4:59
5
\$\begingroup\$

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.

\$\endgroup\$
4
\$\begingroup\$

Mathematica, 25 bytes

1-Plus~Array~{#,#}~Mod~2&
\$\endgroup\$
4
\$\begingroup\$

JavaScript ES6, 55 54 51 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

\$\endgroup\$
  • \$\begingroup\$ It's still a byte shorter to use the index parameters: n=>[...Array(n)].map((_,i,a)=>a.map((_,j)=>(i+j+1)%2)) \$\endgroup\$ – Neil Jun 15 '17 at 18:41
  • \$\begingroup\$ @Neil huh, I never thought to use the third parameter in map, thanks! \$\endgroup\$ – Downgoat Jun 15 '17 at 18:47
  • \$\begingroup\$ @Arnauld thanks! that inspired me to save 5 more bytes! \$\endgroup\$ – Downgoat Jun 15 '17 at 22:55
4
\$\begingroup\$

Retina, 33 30 bytes

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

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.

\$\endgroup\$
  • \$\begingroup\$ $`1$' is just $_. \$\endgroup\$ – Martin Ender Jun 16 '17 at 5:27
  • \$\begingroup\$ @MartinEnder Ah, I'm unfamiliar with $_, thanks! \$\endgroup\$ – Neil Jun 16 '17 at 7:45
3
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Equivalent, and shorter: :&+o~ \$\endgroup\$ – Luis Mendo Jun 15 '17 at 21:25
  • 1
    \$\begingroup\$ Still learning :-) I'll update tomorrow. I liked your other approach too :-) \$\endgroup\$ – Stewie Griffin Jun 15 '17 at 21:44
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – Sanchises Jun 16 '17 at 21:04
  • \$\begingroup\$ @Sanchises Pesky, huh? :-P \$\endgroup\$ – Luis Mendo Jun 16 '17 at 21:09
3
\$\begingroup\$

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]]
\$\endgroup\$
3
\$\begingroup\$

Clojure, 36 bytes

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

Yay, right tool for the job.

\$\endgroup\$
3
\$\begingroup\$

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
\$\endgroup\$
  • \$\begingroup\$ You can cut the » as list-of-lists output is okay and you can also remove s. \$\endgroup\$ – Emigna Jun 16 '17 at 7:27
  • \$\begingroup\$ @Emigna Yep, thanks! \$\endgroup\$ – kalsowerus Jun 16 '17 at 10:43
  • \$\begingroup\$ Explanation is a bit irrelevant. \$\endgroup\$ – Erik the Outgolfer Jun 17 '17 at 14:14
3
\$\begingroup\$

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;
}
\$\endgroup\$
  • \$\begingroup\$ 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. :) \$\endgroup\$ – Kevin Cruijssen Jun 16 '17 at 7:26
  • \$\begingroup\$ @KevinCruijssen Yeah I was still waiting on a response on the space. I didn't think about & having higher precedence than % and &1 == %2 \$\endgroup\$ – PunPun1000 Jun 16 '17 at 12:02
2
\$\begingroup\$

Charcoal, 8 bytes

UON10¶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");
\$\endgroup\$
2
\$\begingroup\$

Pyth, 9 bytes

VQm%+hdN2

Try this!

another 9 byte solution:

mm%+hdk2Q

Try it!

\$\endgroup\$
2
\$\begingroup\$

J, 9 bytes

<0&=$&1 0

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Mathematica, 23 bytes

ToeplitzMatrix@#~Mod~2&
\$\endgroup\$
2
\$\begingroup\$

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!

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ 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 \$\endgroup\$ – Giuseppe Jun 16 '17 at 14:12
  • 1
    \$\begingroup\$ outer(1:n,1:n-1,"+")%%2 is quite a few bytes shorter :) \$\endgroup\$ – JAD Jun 23 '17 at 12:01
2
\$\begingroup\$

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: enter image description here

\$\endgroup\$
2
\$\begingroup\$

C, 69 67 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!

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

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.
\$\endgroup\$
1
\$\begingroup\$

Brachylog, 19 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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!

\$\endgroup\$
1
\$\begingroup\$

CJam, 17 bytes

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

Try it online!

Returns a list (TIO link has formatted output).

\$\endgroup\$
1
\$\begingroup\$

Bash + rs, 42

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

Try it online.

\$\endgroup\$
1
\$\begingroup\$

Cheddar, 38 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

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

\$\endgroup\$
1
\$\begingroup\$

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.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.