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

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

`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

`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

`drawSquare: function [side][    loop 1..side 'x ->        print map 1..side 'y [            (equal? x%2 y%2)? -> 1 -> 0        ]] drawSquare 6print ""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

` # syntax: GAWK -f MOSAIC_MATRIX.AWKBEGIN {    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

`#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
```

## F#

` // Mosaic matrix. Nigel Galloway: February 18th., 2022let 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

### 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 iEnd 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 + 70Screenres size, size, 24ClsWindowtitle "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 yNext xBsave "mosaic_matrix.bmp",0Sleep`
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 Intmosaic 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

Implementation:

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

Examples:

`   mosq 41 0 1 00 1 0 11 0 1 00 1 0 1   mosq 51 0 1 0 10 1 0 1 01 0 1 0 10 1 0 1 01 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(                    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

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 `

## 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	endend;  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```

## Python

### Procedural

`size = 9for 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]] -> Stringdef 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              [ 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

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   : <[email protected]> load "stdlib.ring"load "guilib.ring" size = 8C_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

`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 Windowimport "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:

## 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
```