Latin Squares in reduced form: Difference between revisions

* for n = 1 to 6 (or more) produce the set of reduced Latin Squares; produce a table which shows the size of the set of reduced Latin Squares and compares this value times n! times (n-1)! with the values in [[oeis:A002860|OEIS A002860]].

<br><br>

 

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

{{trans|D}}

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>The four reduced latin squares of order 4 are:

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

{{trans|C#}}

#include <functional>

#include <iostream>

 

return 0;

{{out}}

<pre>The four reduced lating squares of order 4 are:

=={{header|D}}==

{{trans|Go}}

import std.array;

import std.range;

writefln("Order %d: Size %-4d x %d! x %d! => Total %d", n, size, n, n - 1, f);

}

{{out}}

<pre>The four reduced latin squares of order 4 are:

===The Function===

This task uses [[Permutations/Derangements#F.23]]

// Generate Latin Squares in reduced form. Nigel Galloway: July 10th., 2019

let normLS α=

let rec normLS n g=seq{for i in fG n N.[g] do if g=α-2 then yield [|1..α|]::(List.rev (i::n)) else yield! normLS (i::n) (g+1)}

match α with 1->seq[[[|1|]]] |2-> seq[[[|1;2|];[|2;1|]]] |_->Seq.collect(fun n->normLS [n] 1) N.[0]

===The Task===

normLS 4 |> Seq.iter(fun n->List.iter(printfn "%A") n;printfn "");;

{{out}}

<pre>

[|4; 3; 2; 1|]

</pre>

let rec fact n g=if n<2 then g else fact (n-1) n*g

[1..6] |> List.iter(fun n->let nLS=normLS n|>Seq.length in printfn "order=%d number of Reduced Latin Squares nLS=%d nLS*n!*(n-1)!=%d" n nLS (nLS*(fact n 1)*(fact (n-1) 1)))

{{out}}

<pre>

=={{header|Go}}==

This reuses the dList function from the [[Permutations/Derangements#Go]] task, suitably adjusted for the present one.

 

import (

fmt.Printf("Order %d: Size %-4d x %d! x %d! => Total %d\n", n, size, n, n-1, f)

}

 

{{out}}

Order 6: Size 9408 x 6! x 5! => Total 812851200

</pre>

 

=={{header|Java}}==

import java.math.BigInteger;

import java.util.ArrayList;

 

}

 

{{out}}

Size = 6, 9408 * 720 * 120 = 812,851,200

</pre>

 

=={{header|Julia}}==

 

clash(row2, row1::Vector{Int}) = any(i -> row1[i] == row2[i], 1:length(row2))

testlatinsquares()

<pre>

The four reduced latin squares of order 4 are:

=={{header|Kotlin}}==

{{trans|D}}

 

fun dList(n: Int, sp: Int): Matrix {

println("Order $n: Size %-4d x $n! x ${n - 1}! => Total $f".format(size))

}

{{out}}

<pre>The four reduced latin squares of order 4 are:

=={{header|MiniZinc}}==

===The Model (lsRF.mnz)===

%Latin Squares in Reduced Form. Nigel Galloway, September 5th., 2019

include "alldifferent.mzn";

array[1..N,1..N] of var 1..N: p; constraint forall(n in 1..N)(p[1,n]=n /\ p[n,1]=n);

constraint forall(n in 1..N)(alldifferent([p[n,g]|g in 1..N])/\alldifferent([p[g,n]|g in 1..N]));

===The Tasks===

;displaying the four reduced Latin Squares of order 4

include "lsRF.mzn";

output [show_int(1,p[i,j])++

else "" endif

| i,j in 1..4 ] ++ ["\n"];

When the above is run using minizinc --all-solutions -DN=4 the following is produced:

{{out}}

=={{header|Nim}}==

{{trans|Go, Python, D, Kotlin}}

 

 

type

let size = reducedLatinSquares(n, false)

let f = fac(n - 1)^2 * n * size

 

{{out}}

=={{header|Perl}}==

It takes a little under 2 minutes to find order 7.

 

use strict; # https://rosettacode.org/wiki/Latin_Squares_in_reduced_form

length $s <= 1 ? $s :

map { my $f = $_; map "$f$_", perm( $s =~ s/$_//r ) } split //, $s;

{{out}}

<pre>

A Simple backtracking search.<br>

aside: in phix here is no difference between res[r][c] and res[r,c]. I mixed them here, using whichever felt the more natural to me.

{{out}}

<pre>

"2 minutes and 23s"

</pre>

 

=={{header|Python}}==

{{trans|D}}

start -= 1 # use 0 basing

a = range(n)

f = factorial(n - 1)

f *= f * n * size

{{out}}

<pre>The four reduced latin squares of order 4 are:

=={{header|Raku}}==

(formerly Perl 6)

sub postfix:<!>($n) { (constant f = 1, |[\×] 1..*)[$n] }

sub prefix:<!>($n) { (1, 0, 1, -> $a, $b { ($++ + 2) × ($b + $a) } ... *)[$n] }

for 1..6 -> $n {

printf "Order $n: Size %-4d x $n! x {$n-1}! => Total %d\n", $_, $_ * $n! * ($n-1)! given LS-reduced($n).elems

{{out}}

<pre>1 2 3 4

Order 4: Size 4 x 4! x 3! => Total 576

Order 5: Size 56 x 5! x 4! => Total 161280

Order 6: Size 9408 x 6! x 5! => Total 812851200</pre>

 

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

 

// generate derangements of first n numbers, with 'start' in first place.

f = f * f * n * size

Fmt.print("Order $d: Size $-4d x $d! x $d! => Total $d", n, size, n, n-1, f)

 

{{out}}

{{trans|Go}}

This reuses the dList function from the [[Permutations/Derangements#zkl]] task, suitably adjusted for the present one.

if(n<=1) return(n);

rlatin:=n.pump(List(), List.createLong(n,0).copy); // matrix of zeros

println();

}

reducedLatinSquare(4,True);

 

size,f,f := reducedLatinSquare(n), fact(n - 1), f*f*n*size;;

println("Order %d: Size %-4d x %d! x %d! -> Total %,d".fmt(n,size,n,n-1,f));

{{out}}

<pre>