Mosaic matrix

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.

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

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

AdaEdit

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 68Edit

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

ArturoEdit

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

AutoHotkeyEdit

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  

AWKEdit

# 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

CEdit

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


FreeBASICEdit

Text basedEdit

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

GraphicalEdit

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


GoEdit

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 

HaskellEdit

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 │
└                 ┘

JEdit

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

JavaScriptEdit

(() => {
    "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

jqEdit

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

JuliaEdit

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

PascalEdit

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


PerlEdit

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

PhixEdit

See Matrix_with_two_diagonals#Phix and press 'M'.

PicatEdit

ImperativeEdit

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 comprehensionEdit

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


ProcessingEdit

//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);
    } 
  }
}

PythonEdit

ProceduralEdit

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

FunctionalEdit

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

QuackeryEdit

  [ 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 

RakuEdit

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

RedEdit

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

RingEdit

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

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

SidefEdit

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

WrenEdit

Text basedEdit

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 

GraphicalEdit

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

XPL0Edit

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