# Mosaic matrix

Mosaic matrix is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Draw a 'mosaic' matrix which, for the purposes of this task, is a square matrix which has 1's in alternate cells (both horizontally and vertically) starting with a 1 in the top-left hand cell.

Other cells can either be left blank or filled with some other character.
If you can please use GUI
Mosaic Matrix - image

## 11l

Translation of: Python
```V size = 9
L(Row) 0 .< size
L(Col) 0 .< size
I (Row % 2 == 1 & Col % 2 == 1) | (Row % 2 == 0 & Col % 2 == 0)
print(‘1’, end' ‘ ’)
E
print(‘0’, end' ‘ ’)
print()```
Output:
```1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
```

## Action!

```;;; draw a "mosaic matrix" - one with a 1 in the top-left and then
;;; alternating with another character vertically and horizontally

;;; draws a mosaic matrix with height and width = n
PROC drawMosaic( INT n )
CARD i, j, one
FOR i = 1 TO n DO
one = i AND 1
FOR j = 1 TO n DO
Put(' )
IF one = 1 THEN Put('1) ELSE Put('.) FI
one = ( one + 1 ) AND 1
OD
PutE()
OD
RETURN

PROC Main()
drawMosaic( 6 )
PutE()
drawMosaic( 7 )
RETURN```
Output:
``` 1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1

1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
```

```with Ada.Text_Io; use Ada.Text_Io;

procedure Mosaic_Matrix is

type Matrix_Type is array (Positive range <>, Positive range <>) of Character;

function Mosaic (Length : Natural) return Matrix_Type is
begin
return M : Matrix_Type (1 .. Length, 1 .. Length) do
for Row in M'Range (1) loop
for Col in M'Range (2) loop
M (Row, Col) := (if (Row + Col) mod 2 = 0
then '1' else '.');
end loop;
end loop;
end return;
end Mosaic;

procedure Put (M : Matrix_Type) is
begin
for Row in M'Range (1) loop
for Col in M'Range (2) loop
Put (' ');
Put (M (Row, Col));
end loop;
New_Line;
end loop;
end Put;

begin
Put (Mosaic (Length => Natural'Value (Ada.Command_Line.Argument (1))));

exception
when others =>
Put_Line ("Usage: ./mosaic_matrix <side-length>");

end Mosaic_Matrix;
```
Output:
```\$ ./mosaic_matrix 4
1 . 1 .
. 1 . 1
1 . 1 .
. 1 . 1
\$ ./mosaic_matrix 2
1 .
. 1
\$ ./mosaic_matrix 1
1
\$ ./mosaic_matrix 0
\$ ./mosaic_matrix
Usage: ./mosaic_matrix <side-length>
```

## ALGOL 68

```BEGIN # draw a "mosaic matrix" - one with a 1 in the top-left and then  #
# alternating with another character vertically and horiontally   #
# horiontally                                                     #
# draws a mosaic matrix with height and width = n using "1" and "." #
PROC draw mosaic = ( INT n )VOID:
FOR i TO n DO
BOOL one := ODD i;
FOR j TO n DO
print( ( " ", IF one THEN "1" ELSE "." FI ) );
one := NOT one
OD;
print( ( newline ) )
OD # draw mosaic # ;
# test the draw mosaic procedure #
draw mosaic( 10 );
print( ( newline ) );
draw mosaic( 11 )
END```
Output:
``` 1 . 1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1 . 1
1 . 1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1 . 1
1 . 1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1 . 1
1 . 1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1 . 1
1 . 1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1 . 1

1 . 1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1 . 1
```

## ALGOL W

```begin % draw a "mosaic matrix" - one with a 1 in the top-left and then  %
% alternating with another character vertically and horiontally   %
% horiontally                                                     %
% draws a mosaic matrix with height and width = n using "1" and "." %
procedure drawMosaic ( integer value n ) ;
for i := 1 until n do begin
logical one;
one := odd( i );
for j := 1 until n do begin
writeon( s_w := 0, if one then " 1" else " ." );
one := not one
end for_j ;
write()
end drawMosaic ;
% test the draw mosaic procedure %
drawMosaic( 6 );
write();
drawMosaic( 7 )
end.```
Output:
``` 1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1

1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
```

## Arturo

```drawSquare: function [side][
loop 1..side 'x ->
print map 1..side 'y [
(equal? x%2 y%2)? -> 1 -> 0
]
]

drawSquare 6
print ""
drawSquare 9
```
Output:
```1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1```

## AutoHotkey

```for i, v in [8, 9]
result .= "Matrix Size: " v "*" v "`n" matrix2txt(mosaicMatrix(v)) "`n"
MsgBox % result
return

mosaicMatrix(size){
M := []
loop % size {
row := A_Index
loop % size
M[row, A_Index] := (Toggle:=!Toggle)  ? 1 : 0
, toggle := (A_Index = size && size/2 = floor(size/2)) ? !toggle : toggle
}
return M
}

matrix2txt(M){
for row , obj in M {
for col, v in obj
result .= M[row, col] "  "
result .= "`n"
}
return result
}
```
Output:
```Matrix Size: 8*8
1  0  1  0  1  0  1  0
0  1  0  1  0  1  0  1
1  0  1  0  1  0  1  0
0  1  0  1  0  1  0  1
1  0  1  0  1  0  1  0
0  1  0  1  0  1  0  1
1  0  1  0  1  0  1  0
0  1  0  1  0  1  0  1

Matrix Size: 9*9
1  0  1  0  1  0  1  0  1
0  1  0  1  0  1  0  1  0
1  0  1  0  1  0  1  0  1
0  1  0  1  0  1  0  1  0
1  0  1  0  1  0  1  0  1
0  1  0  1  0  1  0  1  0
1  0  1  0  1  0  1  0  1
0  1  0  1  0  1  0  1  0
1  0  1  0  1  0  1  0  1  ```

## AWK

```# syntax: GAWK -f MOSAIC_MATRIX.AWK
BEGIN {
for (n=6; n<=7; n++) {
for (i=1; i<=n; i++) {
for (j=1; j<=n; j++) {
tmp = ((i+j) % 2 == 0) ? 1 : 0
printf("%2d",tmp)
}
printf("\n")
}
print("")
}
exit(0)
}
```
Output:
``` 1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1

1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
```

## BQN

```Mosaic ← =⌜˜2|↕

Mosaic 6
```
Output:
```┌─
╵ 1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
┘```

## C

```#include <stdio.h>

void mosaicMatrix(unsigned int n) {
int i, j;
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if ((i + j) % 2 == 0) {
printf("%s ", "1");
} else {
printf("%s ", "0");
}
}
printf("\n");
}
}

int main() {
mosaicMatrix(10);
printf("\n");
mosaicMatrix(11);
return 0;
}
```
Output:
```1 0 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1 0 1

1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
```

## C++

```#include <concepts>
#include <iostream>

// Print each element of a matrix according to a predicate.  It
// will print a '1' if the predicate function is true, otherwise '0'.
void PrintMatrix(std::predicate<int, int, int> auto f, int size)
{
for(int y = 0; y < size; y++)
{
for(int x = 0; x < size; x++)
{
std::cout << " " << f(x, y, size);
}
std::cout << "\n";
}
std::cout << "\n";
}

int main()
{
// a lambda to create a mosaic
auto mosaic = [](int x, int y, [[maybe_unused]]int size)
{
return (x + y) % 2 == 0;
};

PrintMatrix(mosaic, 8);
PrintMatrix(mosaic, 9);
}
```
Output:
``` 1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
```

## Delphi

Works with: Delphi version 6.0

Another example of modular code and saving time by reusing subroutines and structures. Most of the code from is take from this previously worked example:

```{Define a matrix}

type TMatrix = array of array of double;

procedure DisplayMatrix(Memo: TMemo; Mat: TMatrix);
{Display specified matrix}
var X,Y: integer;
var S: string;
begin
S:='';
for Y:=0 to High(Mat) do
begin
S:=S+'[';
for X:=0 to High(Mat[0]) do
if X=0 then S:=S+Format('%0.0f',[Mat[X,Y]])
else S:=S+Format('%2.0f',[Mat[X,Y]]);
S:=S+']'+#\$0D#\$0A;
end;
end;

procedure ClearMatrix(var Mat: TMatrix; Value: double);
{Set all elements of the matrix to specified value}
var X,Y: integer;
begin
for Y:=0 to High(Mat) do
for X:=0 to High(Mat[0]) do Mat[X,Y]:=0;
end;

procedure SetMosaicMatrix(var Mat: TMatrix);
{Set matrix to mosaic pattern}
var X,Y: integer;
begin
{Set every other cell to one or zero}
for Y:=0 to High(Mat) do
for X:=0 to High(Mat) do Mat[X,Y]:=(X+Y+1) mod 2;
end;

procedure BuildMosaicMatrix(var Mat: TMatrix; Size: integer);
{Build a matrix with diagonals of the specified size }
var X,Y: integer;
begin
SetLength(Mat,Size,Size);
ClearMatrix(Mat,0);
SetMosaicMatrix(Mat);
end;

procedure BuildShowMosaicMatrix(Memo: TMemo; var Mat: TMatrix; Size: integer);
{Build and show a matrix of specific size}
begin
BuildMosaicMatrix(Mat,Size);
DisplayMatrix(Memo,Mat);
end;

procedure DisplayMosaicMatrices(Memo: TMemo);
{Build and display matrices of various sizes}
var Mat: TMatrix;
var I: integer;
begin
for I:=3 to 10 do BuildShowMosaicMatrix(Memo,Mat,I);
end;
```
Output:
```Matrix =  3 X  3
[1 0 1]
[0 1 0]
[1 0 1]

Matrix =  4 X  4
[1 0 1 0]
[0 1 0 1]
[1 0 1 0]
[0 1 0 1]

Matrix =  5 X  5
[1 0 1 0 1]
[0 1 0 1 0]
[1 0 1 0 1]
[0 1 0 1 0]
[1 0 1 0 1]

Matrix =  6 X  6
[1 0 1 0 1 0]
[0 1 0 1 0 1]
[1 0 1 0 1 0]
[0 1 0 1 0 1]
[1 0 1 0 1 0]
[0 1 0 1 0 1]

Matrix =  7 X  7
[1 0 1 0 1 0 1]
[0 1 0 1 0 1 0]
[1 0 1 0 1 0 1]
[0 1 0 1 0 1 0]
[1 0 1 0 1 0 1]
[0 1 0 1 0 1 0]
[1 0 1 0 1 0 1]

Matrix =  8 X  8
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]

Matrix =  9 X  9
[1 0 1 0 1 0 1 0 1]
[0 1 0 1 0 1 0 1 0]
[1 0 1 0 1 0 1 0 1]
[0 1 0 1 0 1 0 1 0]
[1 0 1 0 1 0 1 0 1]
[0 1 0 1 0 1 0 1 0]
[1 0 1 0 1 0 1 0 1]
[0 1 0 1 0 1 0 1 0]
[1 0 1 0 1 0 1 0 1]

Matrix = 10 X 10
[1 0 1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1 0 1]
```

## EasyLang

Translation of: Nim
```proc mosaic side . .
start = 1
for i to side
c = start
for j to side
write c & " "
c = 1 - c
.
print ""
start = 1 - start
.
.
mosaic 6```
Output:
```1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
```

## F#

```// Mosaic matrix. Nigel Galloway: February 18th., 2022
let m11 m=Array2D.init m m (fun n g->if (n+g)%2=0 then 1 else 0)
printfn "%A\n\n%A" (m11 5) (m11 6)
```
Output:
```[[1; 0; 1; 0; 1]
[0; 1; 0; 1; 0]
[1; 0; 1; 0; 1]
[0; 1; 0; 1; 0]
[1; 0; 1; 0; 1]]

[[1; 0; 1; 0; 1; 0]
[0; 1; 0; 1; 0; 1]
[1; 0; 1; 0; 1; 0]
[0; 1; 0; 1; 0; 1]
[1; 0; 1; 0; 1; 0]
[0; 1; 0; 1; 0; 1]]
```

## Factor

Works with: Factor version 0.99
```USING: accessors colors kernel math math.matrices ui
ui.pens.solid ;
IN: mosaic

: <square> ( m n -- gadget )
+ 2 mod 0 = [
" 1 " <label> COLOR: AntiqueWhite2 <solid> >>interior
[ 50 >>size ] change-font
] [ "" <label> ] if ;

: <checkerboard> ( n -- gadget )
dup [ <square> ] <matrix-by-indices> <grid>
COLOR: gray <grid-lines> >>boundary ;

MAIN: [ 8 <checkerboard> "Mosaic" open-window ]
```
Output:

## FreeBASIC

### Text based

```Sub mosaicMatrix(n As Integer)
For i As Integer = 1 To n
For j As Integer = 1 To n
Print Iif((i + j) Mod 2 = 0, "1 ", ". ");
Next j
Print
Next i
End Sub

mosaicMatrix(9)
Sleep```
Output:
```1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1```

### Graphical

```Dim As Integer n = 9, size = 60 * n + 70
Screenres size, size, 24
Cls
Windowtitle "Mosaic matrix"

Dim As Integer beige = Rgb(245, 245, 220), brown = Rgb(171, 82, 54)
For x As Integer = 0 To n
For y As Integer = 0 To n
Dim As Integer cx = x*60 + 10
Dim As Integer cy = y*60 + 10
If (x + y) Mod 2 = 0 Then
Line (cx,cy) - (cx+50, cy+50), brown, BF
Draw String (cx + 20, cy + 20), "1", beige
Else
Line (cx,cy) - (cx+50, cy+50), beige, BF
End If
Next y
Next x
Bsave "mosaic_matrix.bmp",0
Sleep```
Output:

## Go

```package main

import "fmt"

func mosaicMatrix(n uint) {
for i := uint(0); i < n; i++ {
for j := uint(0); j < n; j++ {
if (i+j)%2 == 0 {
fmt.Printf("%s ", "1")
} else {
fmt.Printf("%s ", ".")
}
}
fmt.Println()
}
}

func main() {
mosaicMatrix(7)
fmt.Println()
mosaicMatrix(8)
}
```
Output:
```1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1
. 1 . 1 . 1 .
1 . 1 . 1 . 1

1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1
1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1
1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1
1 . 1 . 1 . 1 .
. 1 . 1 . 1 . 1
```

```import Data.Matrix (Matrix, matrix)

mosaic :: Int -> Matrix Int
mosaic n =
matrix n n ((`rem` 2) . succ . uncurry (+))

main :: IO ()
main = mapM_ (print . mosaic) [7, 8]
```
Output:
```┌               ┐
│ 1 0 1 0 1 0 1 │
│ 0 1 0 1 0 1 0 │
│ 1 0 1 0 1 0 1 │
│ 0 1 0 1 0 1 0 │
│ 1 0 1 0 1 0 1 │
│ 0 1 0 1 0 1 0 │
│ 1 0 1 0 1 0 1 │
└               ┘
┌                 ┐
│ 1 0 1 0 1 0 1 0 │
│ 0 1 0 1 0 1 0 1 │
│ 1 0 1 0 1 0 1 0 │
│ 0 1 0 1 0 1 0 1 │
│ 1 0 1 0 1 0 1 0 │
│ 0 1 0 1 0 1 0 1 │
│ 1 0 1 0 1 0 1 0 │
│ 0 1 0 1 0 1 0 1 │
└                 ┘```

## J

Implementation:

```mosq=: [: =/~ 2 | i.
```

Examples:

```   mosq 4
1 0 1 0
0 1 0 1
1 0 1 0
0 1 0 1
mosq 5
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
```

## JavaScript

```(() => {
"use strict";

// ------------------ MOSAIC MATRIX ------------------

// mosaic :: Int -> [[Int]]
const mosaic = n => matrix(n)(n)(
row => col => (1 + row + col) % 2
);

// ---------------------- TEST -----------------------
// main :: IO ()
const main = () =>
// Matrices of dimensions 7 and 8.
[7, 8].map(
compose(
showMatrix(String),
mosaic
)
).join("\n\n");

// --------------------- GENERIC ---------------------

// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
const compose = (...fs) =>
// A function defined by the right-to-left
// composition of all the functions in fs.
fs.reduce(
(f, g) => x => f(g(x)),
x => x
);

// matrix Int -> Int -> (Int -> Int -> a) -> [[a]]
const matrix = nRows => nCols =>
// A matrix of a given number of columns and rows,
// in which each value is a given function of its
// (zero-based) column and row indices.
f => Array.from({
length: nRows
}, (_, iRow) => Array.from({
length: nCols
}, (__, iCol) => f(iRow)(iCol)));

// showMatrix :: (a -> String) -> [[a]] -> String
const showMatrix = fShow =>
rows => 0 < rows.length ? (() => {
const w = fShow(Math.max(...rows.flat())).length;

return rows.map(
cells => cells.map(
).join(" ")
).join("\n");
})() : "";

// main
return main();
})();
```
Output:
```1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1

1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

```def mosaicMatrix:
[range(0;.) | . % 2] as \$one
| [range(0;.) | (. + 1) % 2] as \$two
| [range(0;.) | if .%2 == 1 then \$one else \$two end];```

Example:

```def display:
map(join(" ")) | join("\n");

9|mosaicMatrix|display```
Output:
```1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
```

## Julia

```julia> mosaicmat(n) = (m = n + iseven(n); reshape([Int(isodd(i)) for i in 1:m^2], m, m)[1:n, 1:n])
mosaicmat (generic function with 1 method)

julia> mosaicmat(1)
1×1 Matrix{Int64}:
1

julia> mosaicmat(2)
2×2 Matrix{Int64}:
1  0
0  1

julia> mosaicmat(3)
3×3 Matrix{Int64}:
1  0  1
0  1  0
1  0  1

julia> mosaicmat(4)
4×4 Matrix{Int64}:
1  0  1  0
0  1  0  1
1  0  1  0
0  1  0  1

julia> mosaicmat(5)
5×5 Matrix{Int64}:
1  0  1  0  1
0  1  0  1  0
1  0  1  0  1
0  1  0  1  0
1  0  1  0  1
```

## K

K6

```mosaic: {x=/:x}2!!:

mosaic 6
```
Output:
```(1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1)```

## Maxima

```/* Function that returns a mosaic matrix */
mosaic(n):=genmatrix(lambda([i,j],charfun(evenp(abs(i-j)))),n,n)\$

/* Alternative fumction */
altern_mosaic(n):=genmatrix(lambda([i,j],if evenp(abs(i-j)) then 1 else 0),n,n)\$

/* Examples */
mosaic(3);
mosaic(4);
```
Output:
```matrix(
[1,	0,	1],
[0,	1,	0],
[1,	0,	1]
)
matrix(
[1,	0,	1,	0],
[0,	1,	0,	1],
[1,	0,	1,	0],
[0,	1,	0,	1]
)
```

## Nim

```proc drawMosaicMatrix(side: Positive) =
var start = 1
for i in 0..<side:
var c = start
for j in 0..<side:
stdout.write c
c = 1 - c
echo()
start = 1 - start

echo "6x6 matrix:\n"
drawMosaicMatrix(6)

echo "\n7x7 matrix:\n"
drawMosaicMatrix(7)
```
Output:
```6x6 matrix:

101010
010101
101010
010101
101010
010101

7x7 matrix:

1010101
0101010
1010101
0101010
1010101
0101010
1010101
```

## Pascal

```program mosaicMatrix(output);

const
filledCell = '1';
emptyCell = '⋅';

procedure printMosaicMatrix(dimension: integer);
var
line: integer;
begin
{ NB: In Pascal, `for`-loop-limits are evaluated exactly once. }
for line := 1 to dimension do
begin
for dimension := 1 to dimension do
begin
{ `ord(odd(line))` is either zero or one. }
if odd(dimension + ord(odd(line))) then
begin
{ `write(emptyCell)` is shorthand for `write(output, emptyCell)`. }
write(emptyCell)
end
else
begin
write(filledCell)
end
end;
writeLn
end
end;

begin
printMosaicMatrix(9)
end.
```
Output:
```1⋅1⋅1⋅1⋅1
⋅1⋅1⋅1⋅1⋅
1⋅1⋅1⋅1⋅1
⋅1⋅1⋅1⋅1⋅
1⋅1⋅1⋅1⋅1
⋅1⋅1⋅1⋅1⋅
1⋅1⋅1⋅1⋅1
⋅1⋅1⋅1⋅1⋅
1⋅1⋅1⋅1⋅1
```

## Perl

```use strict;
use warnings;
use feature 'say';

my \$n = 5;
say join ' ', @\$_ for map { \$_%2 ? [map { \$_%2 ? 1 : 0 } 1..\$n] : [map { \$_%2 ? 0 : 1 } 1..\$n] } 1..\$n;
```
Output:
```1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1```

## Phix

See Matrix_with_two_diagonals#Phix and press 'M'.

## Picat

### Imperative

```go =>
N = 6,
A = new_array(N,N),
bind_vars(A,"."),
foreach(I in 1..N)
foreach(J in 1..N, I mod 2 == J mod 2)
A[I,J] := "1"
end,
println(A[I].to_list.join(" "))
end.```
Output:
```1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1
1 . 1 . 1 .
. 1 . 1 . 1```

### List comprehension

```main =>
N=11,
[[((1+I^J)/\1).to_string:J in 1..N].join:I in 1..N].join("\n").println.```
Output:
```1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1```

## PL/M

Works with: 8080 PL/M Compiler

... under CP/M (or an emulator)

```100H: /* DRAW SOME MOSAIC MATRICES WITH ALTERNATING 1S and .S                */

/* CP/M SYSTEM CALL AND I/O ROUTINES                                      */
BDOS:      PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
PR\$CHAR:   PROCEDURE( C ); DECLARE C BYTE;    CALL BDOS( 2, C );  END;
PR\$NL:     PROCEDURE;   CALL PR\$CHAR( 0DH ); CALL PR\$CHAR( 0AH ); END;

DRAW\$MOSAIC: PROCEDURE( N );
DECLARE N BYTE;
DECLARE ( I, J, ONE ) BYTE;
DO I = 1 TO N;
ONE = I;            /* EVEN NUMBERS ARE FALSE, ODD ARE TRUE IN PL/M */
DO J = 1 TO N;
CALL PR\$CHAR( ' ' );
IF ONE THEN CALL PR\$CHAR( '1' ); ELSE CALL PR\$CHAR( '0' );
ONE = NOT ONE;
END;
CALL PR\$NL;
END;
END DRAW\$MOSAIC ;

CALL DRAW\$MOSAIC( 6 );
CALL PR\$NL;
CALL DRAW\$MOSAIC( 7 );

EOF```
Output:
``` 1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1

1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
```

## Processing

```//Aamrun, 27th June 2022

size(1000,1000);

textSize(50);

for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
noFill();
square(i*100,j*100,100);
fill(#000000);
if((i+j)%2==0){
text("1",i*100+50,j*100+50);
}
else{
text("0",i*100+50,j*100+50);
}
}
}
```

## Python

### Procedural

```size = 9
for Row in range(size):
for Col in range(size):
if (Row % 2 == 1 and Col % 2 == 1) or (Row % 2 == 0 and Col % 2 == 0):
print("1", end=" ")
else:
print("0", end=" ")
print()
```

Output:
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1

### Functional

No need for nested conditionals here.

```'''Mosaic grid'''

# mosaic :: Int -> [[Int]]
def mosaic(n):
'''Grid of alternating ones and zeroes,
starting with one at top left.
'''
return matrix(
n, n,
lambda y, x: (1 + y + x) % 2
)

# ------------------------- TEST -------------------------
# main :: IO ()
def main():
'''Test'''
for n in [7, 8]:
print(
showMatrix(
mosaic(n)
) + '\n'
)

# ----------------------- GENERIC ------------------------

# matrix :: Int -> Int -> ((Int, Int) -> a) -> [[a]]
def matrix(nRows, nCols, f):
'''A matrix of a given number of columns and rows,
in which each value is a given function over the
tuple of its (one-based) row and column indices.
'''
return [
[f(y, x) for x in range(1, 1 + nCols)]
for y in range(1, 1 + nRows)
]

# showMatrix :: [[a]] -> String
def showMatrix(rows):
'''String representation of a matrix'''
return '\n'.join([
' '.join([str(x) for x in y]) for y in rows
])

# MAIN ---
if __name__ == '__main__':
main()
```
Output:
```1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1

1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1```

## Quackery

```  [ 1 & not ]                  is even     (   n --> b )

[ dip [ temp put [] ]
temp share times
[ temp share split
dip
[ nested join ] ]
drop temp release ]       is matrixify ( n [ --> [ )

[ dup 2dup * 1+ 1 >>
' [ 1 0 ] swap of
matrixify
swap even if
[ [] swap witheach
[ i even if
nested join ] ] ] is mosaic    (   n --> [ )

8 mosaic
witheach
[ witheach [ echo sp ] cr ]
cr
9 mosaic
witheach
[ witheach [ echo sp ] cr ]```
Output:
```1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
```

## Raku

This isn't a matrix, especially if it is supposed to be graphical; it's a very small (or extremely low resolution) bitmap.

```sub checker (\$n) { (^\$n).map: { 1 xx \$n Z× (flat (\$_ %% 2, \$_ % 2) xx *) } }

.put for checker 7;
put '';
.put for checker 8;
```
Output:
```1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1

1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1
1 0 1 0 1 0 1 0
0 1 0 1 0 1 0 1```

## Red

```Red[]

mosaic: function [size][
matrix: copy [
title "Mosaic matrix"
style cell: base 50x50 font-size 20
style one: cell brown font-color beige "1"
style zero: cell beige
]
repeat i size [
repeat j size [
append matrix either even? i + j ['one] ['zero]
]
append matrix 'return
]
view matrix
]

mosaic 8
```
Output:

Similar to graphical Wren entry

## Ring

```# Project : Mosaic matrix
# Date    : 2022/18/02
# Author  : Gal Zsolt (~ CalmoSoft ~)
# Email   : <calmosoft@gmail.com>

size = 8
C_Spacing = 1

Button = newlist(size,size)
LayoutButtonRow = list(size)

app = new qApp
{
win = new qWidget() {
setWindowTitle('Identity Matrix')
move(500,100)
reSize(600,600)
winheight = win.height()
fontSize = 18 + (winheight / 100)

LayoutButtonMain = new QVBoxLayout()
LayoutButtonMain.setSpacing(C_Spacing)
LayoutButtonMain.setContentsmargins(0,0,0,0)

for Row = 1 to size
LayoutButtonRow[Row] = new QHBoxLayout() {
setSpacing(C_Spacing)
setContentsmargins(0,0,0,0)
}
for Col = 1 to size
Button[Row][Col] = new QPushButton(win) {
setSizePolicy(1,1)
}

next
next
LayoutDataRow1 = new QHBoxLayout() { setSpacing(C_Spacing) setContentsMargins(0,0,0,0) }
setLayout(LayoutButtonMain)
show()
}
pBegin()
exec()
}

func pBegin()
for Row = 1 to size
for Col = 1 to size
if (Row%2 = 1 and Col%2 = 1) or (Row%2 = 0 and Col%2 = 0)
Button[Row][Col].setStyleSheet(C_ButtonOrangeStyle)
Button[Row][Col].settext("1")
ok
next
next```

Output image:
Mosaic Matrix

## RPL

Filling a matrix

```≪ → n
≪ n DUP 2 →LIST 0 CON
1 n FOR r
1 n FOR c
r c 2 →LIST r c + 2 MOD NOT PUT
NEXT NEXT
≫ ≫ 'MOZTX' STO
```
```4 MOZTX
```
Output:
```1: [[ 1 0 1 0 ]
[ 0 1 0 1 ]
[ 1 0 1 0 ]
[ 0 1 0 1 ]]
```

Filling the stack

```« → n
« 1 n FOR j
j 2 MOD
2 n START DUP NOT NEXT
NEXT
n DUP 2 →LIST →ARRY
» » 'MOZTX' STO
```

Direct approach

Latest RPL versions have a specific instruction to generate a matrix ruled by a formula.

```≪ DUP 'NOT(I+J) MOD 2' LCXM →NUM ≫ 'MOZTX' STO
```

## Sidef

```func mosaic_matrix(n) {
n.of {|k|
var(a,b) = (k.is_even ? (1,0) : (0,1))
n.of {|j| j.is_even ? a : b }
}
}

mosaic_matrix(5).each { .join(' ').say }; say ''
mosaic_matrix(6).each { .join(' ').say }
```
Output:
```1 0 1 0 1
0 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 1 0 1

1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
```

## Wren

### Text based

```var mosaicMatrix = Fn.new { |n|
for (i in 0...n) {
for (j in 0...n) {
System.write(((i + j) % 2 == 0) ? "1 " : ". ")
}
System.print()
}
}

mosaicMatrix.call(9)
```
Output:
```1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
. 1 . 1 . 1 . 1 .
1 . 1 . 1 . 1 . 1
```

### Graphical

Library: DOME
Library: Go-fonts
```import "dome" for Window
import "graphics" for Canvas, Color, Font, ImageData

class Main {
construct new(n) {
var size = 60 * n + 10
Window.resize(size, size)
Canvas.resize(size, size)
Window.title = "Mosaic matrix"
// see Go-fonts page
Canvas.font = "Go-Regular20"
var beige = Color.new(245, 245, 220)
Canvas.cls(Color.lightgray)
for (x in 0...n) {
for (y in 0...n) {
var cx = x*60 + 10
var cy = y*60 + 10
if ((x + y) % 2 == 0) {
Canvas.rectfill(cx, cy, 50, 50, Color.brown)
Canvas.print("1", cx + 20, cy + 15, beige)
} else {
Canvas.rectfill(cx, cy, 50, 50, beige)
}
}
}
// save to .png file for publication
var outputImage = ImageData.create("", size, size)
for (x in 0...size) {
for (y in 0...size) outputImage.pset(x, y, Canvas.pget(x, y))
}
outputImage.saveToFile("mosaic_matrix.png")
}

init() {}

update() {}

draw(alpha) {}
}

var Game = Main.new(9)
```
Output:

## XPL0

```proc DrawMat(S);
int  S, I, J;
[for I:= 0 to S-1 do
[for J:= 0 to S-1 do
Text(0, if (J xor I) and 1 then "0 " else "1 ");
CrLf(0);
];
];
[DrawMat(6);  CrLf(0);
DrawMat(7);  CrLf(0);
]```
Output:
```1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1
1 0 1 0 1 0
0 1 0 1 0 1

1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
0 1 0 1 0 1 0
1 0 1 0 1 0 1
```