I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

Mosaic matrix

From Rosetta Code
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.
Task

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

Ada[edit]

with Ada.Text_Io; use Ada.Text_Io;
with Ada.Command_Line;
 
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[edit]

BEGIN # draw a "mosaic matrix" - one with a 1 in the top-left and then  #
# alternating with another character vertically and horiontally #
# draws a mosaic matrix with height and width = n using "1" and "." #
PROC draw mosaic = ( INT n )VOID:
BEGIN
CHAR set = "1";
CHAR reset = ".";
FOR i TO n DO
CHAR c := IF ODD i THEN set ELSE reset FI;
FOR j TO n DO
print( ( " ", c ) );
c := IF c = set THEN reset ELSE set FI
OD;
print( ( newline ) )
OD
END # 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

Arturo[edit]

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

AWK[edit]

 
# 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

C[edit]

#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++[edit]

#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

F#[edit]

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


FreeBASIC[edit]

Text based[edit]

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[edit]

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:

https://www.dropbox.com/s/nbxrttz0j99usos/mosaic_matrix.bmp?dl=0


Go[edit]

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 

Haskell[edit]

import Data.Matrix (Matrix, matrix)
 
mosaic :: Int -> Matrix Int
mosaic n =
let go (row, col) = succ (col + row) `rem` 2
in matrix n n go
 
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[edit]

Implementation:

mosq=:{{0=2|+/~i.y}}

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[edit]

(() => {
"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(
x => fShow(x).padStart(w, " ")
).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[edit]

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[edit]

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
 

Perl[edit]

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[edit]

See Matrix_with_two_diagonals#Phix and press 'M'.

Python[edit]

Procedural[edit]

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[edit]

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[edit]

  [ 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
[ behead join ]
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[edit]

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[edit]

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[edit]

 
# Project : Mosaic matrix
# Date  : 2022/18/02
# Author  : Gal Zsolt (~ CalmoSoft ~)
# Email  : <[email protected]>
 
load "stdlib.ring"
load "guilib.ring"
 
size = 8
C_Spacing = 1
 
C_ButtonBlueStyle = 'border-radius:6px;color:black; background-color: blue'
C_ButtonOrangeStyle = 'border-radius:6px;color:black; background-color: orange'
 
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)
}
 
LayoutButtonRow[Row].AddWidget(Button[Row][Col])
next
LayoutButtonMain.AddLayout(LayoutButtonRow[Row])
next
LayoutDataRow1 = new QHBoxLayout() { setSpacing(C_Spacing) setContentsMargins(0,0,0,0) }
LayoutButtonMain.AddLayout(LayoutDataRow1)
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

Sidef[edit]

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[edit]

Text based[edit]

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[edit]

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
Font.load("Go-Regular20", "Go-Regular.ttf", 20)
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:

https://commons.wikimedia.org/wiki/File:Mosaic_matrix.png

XPL0[edit]

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