Random Latin squares: Difference between revisions

 

A Latin square of size <code>n</code> is an arrangement of <code>n</code> symbols in an <code>n-by-n</code> square in such a way that each row and column has each symbol appearing exactly once.<br>

 

;Example n=4 randomised Latin square:

 

;Note:

 

;Reference:

{{trans|Python}}

 

assert(matrix.len == matrix[0].len)

V r = [[0] * matrix.len] * matrix.len

L(i) [3, 3, 5, 5]

V square = rls(i)

_check(square)

 

{{out}}

0 3 1 2 4

</pre>

 

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre>[1, 4, 3, 0, 2]

=={{header|C++}}==

{{trans|Java}}

#include <chrono>

#include <iostream>

latinSquare(10);

return 0;

{{out}}

<pre>[4, 3, 1, 2, 0]

=={{header|C sharp|C#}}==

{{trans|Kotlin}}

using System.Collections.Generic;

 

}

}

{{out}}

<pre>[3, 0, 1, 4, 2]

=={{header|D}}==

{{trans|C#}}

import std.random;

import std.stdio;

 

latinSquare(10);

{{out}}

<pre>[2, 4, 3, 1, 0]

[7, 0, 6, 2, 5, 4, 3, 8, 1, 9]

[9, 7, 5, 4, 1, 3, 0, 6, 2, 8]</pre>

 

=={{header|F_Sharp|F#}}==

// Generate 2 Random Latin Squares of order 5. Nigel Galloway: July 136th., 2019

let N=let N=System.Random() in (fun n->N.Next(n))

let rc()=let β=lN2p [|0;N 4;N 3;N 2|] [|0..4|] in Seq.item (N 56) (normLS 5) |> List.map(lN2p [|N 5;N 4;N 3;N 2|]) |> List.permute(fun n->β.[n]) |> List.iter(printfn "%A")

rc(); printfn ""; rc()

{{out}}

<pre>

 

=={{header|Factor}}==

prettyprint random sequences sets ;

IN: rosetta-code.random-latin-squares

: random-latin-squares ( -- ) [ 5 ls simple-table. nl ] twice ;

 

{{out}}

<pre>

3 1 2 4 0

</pre>

 

=={{header|Go}}==

===Restarting Row method===

As the task is not asking for large squares to be generated and even n = 10 is virtually instant, we use a simple brute force approach here known as the 'Restarting Row' method (see Talk page). However, whilst easy to understand, this method does not produce uniformly random squares.

 

import (

latinSquare(5)

latinSquare(10) // for good measure

 

{{out}}

===Latin Squares in Reduced Form method===

Unlike the "Restarting Row" method, this method does produce uniformly random Latin squares for n <= 6 (see Talk page) but is more involved and therefore slower. It reuses some (suitably adjusted) code from the [https://rosettacode.org/wiki/Latin_Squares_in_reduced_form#Go Latin Squares in Reduced Form] and [https://rosettacode.org/wiki/Permutations#non-recursive.2C_lexicographical_order Permutations] tasks.

 

import (

fmt.Println("\nA randomly generated latin square of order 6 is:\n")

generateLatinSquares(6, 1, 1)

 

{{out}}

4 2 3 1 5 0

</pre>

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.Collections;

import java.util.Iterator;

latinSquare(10);

}

{{out}}

<pre>[1, 3, 4, 0, 2]

 

=={{header|Javascript}}==

class Latin {

constructor(size = 3) {

}

new Latin(5);

{{out}}

<pre>

1 2 3 5 4

2 3 5 4 1

</pre>

 

=={{header|Julia}}==

Using the Python algorithm as described in the discussion section.

 

shufflerows(mat) = mat[shuffle(1:end), :]

 

printlatinsquare(5), println("\n"), printlatinsquare(5)

<pre>

1 3 0 4 2

=={{header|Kotlin}}==

{{trans|Go}}

 

fun printSquare(latin: matrix) {

latinSquare(5)

latinSquare(10) // for good measure

{{out}}

<pre>[4, 1, 2, 3, 0]

We use the stack of values, a linked list, for pushing to top (Push) or to bottom (Data), and we can pop from top using Number or by using Read A to read A from stack. Also we can shift from a chosen position to top using Shift, or using shiftback to move an item from top to chosen position. So we shuffle items by shifting them.

 

Module FastLatinSquare {

n=5

End Sub

}

 

===Hard Way===

for 20X20 need 22 min (as for 9.8 version)

 

Module LatinSquare (n, z=1, f$="latin.dat", NewFile As Boolean=False) {

If Not Exist(f$) Or NewFile Then

LatinSquare 16

 

{{out}}

<pre style="height:30ex;overflow:scroll">

14 1 9 6 10 5 11 3 16 2 4 13 12 15 8 7

</pre >

 

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use feature 'say';

}

 

{{out}}

<pre>B A

=={{header|Phix}}==

Brute force, begins to struggle above 42.

{{out}}

<pre>

ZL6K5NFVMCYbXfA8Oe43g7dUcDa9JTEQGSWB1PR2IH

</pre>

 

=={{header|Python}}==

from copy import deepcopy

 

print(_to_text(square))

_check(square)

 

{{out}}

4 10 9 0 3 7 2 5 1 11 6 8

0 6 11 9 1 3 5 10 2 7 8 4</pre>

 

=={{header|Raku}}==

{{trans|Python}}

 

 

sub random ( @ls, :$size = 5 ) {

 

# Or, if you'd prefer:

{{out|Sample output}}

<pre> V Z M J U

 

The symbols could be any characters (except those that contain a blank), &nbsp; but the numbers from &nbsp; '''0''' ──► '''N-1''' &nbsp; are used.

parse arg N seed . /*obtain the optional argument from CL.*/

if N=='' | N=="," then N= 5 /*Not specified? Then use the default.*/

do j=1 for N /* [↓] display rows of random Latin sq*/

say translate(subword(zz, j, N), , '_') /*translate leading underbar to blank. */

{{out|output|text=&nbsp; for 1^st run when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

load "stdlib.ring"

load "guilib.ring"

###====================================================================================

 

 

[https://www.mediafire.com/file/6fruvfgydnbmtyj/RandomLatinSquares.jpg/file Random Latin Squares - image]

 

=={{header|Ruby}}==

This crude algorithm works fine up to a square size of 10; higher values take too much time and memory. It creates an array of all possible permutations, picks a random one as first row an weeds out all permutations which cannot appear in the remaining square. Repeat picking and weeding until there is a square.

 

def generate_square

 

2.times{print_square( generate_square)}

{{out}}<pre>

3 4 2 1 5

4 1 3 5 2

 

</pre>

 

=={{header|zkl}}==

if(n<=0) return(T);

square,syms := List(), symbols.walker().walk(n);

T.zip(square.shuffle().xplode()).shuffle();

}

randomLatinSquare(5, ["A".."Z"]) : rls2String(_).println("\n");

{{out}}

<pre>