Output a Latin Square

Question

An \$n\times n\$ Latin Square is a grid containing exactly \$n\$ distinct values where the values in each row and column are distinct. For example,

$$\begin{matrix} A & B & C \\ C & A & B \\ B & C & A \\ \end{matrix}$$

is a Latin square as no row or column contains a repeated value.

You are to take a positive integer \$n\$ as input and output an \$n\times n\$ Latin Square. The values can be any \$n\$ distinct values, and do not have to be consistent for different \$n\$. Your program should be consistent and deterministic, so running it with the same input should always produce the same output.

You may output in any reasonable manner, including a flat array consisting of \$n^2\$ values, or as a list of \$n\$ lists, each containing \$n\$ values. You may input and output in any convenient method

This is code-golf, so the shortest code in bytes wins.

Test cases

_{These are just some possible outputs, your program may differ so long as the output is correct}

1 [[1]]
2 [[1, 2], [2, 1]]
3 [[1, 2, 3], [2, 3, 1], [3, 1, 2]]
4 [[1, 2, 3, 4], [2, 1, 4, 3], [3, 4, 1, 2], [4, 3, 2, 1]]
5 [[1, 2, 3, 4, 5], [2, 3, 5, 1, 4], [3, 5, 4, 2, 1], [4, 1, 2, 5, 3], [5, 4, 1, 3, 2]]

Answer 1

Python 2, 37 bytes

Outputs a flattened \$ n \times n \$ latin square.

lambda n:((range(n)*-~n)[1:]*n)[::~n]

Try it online!

Answer 2

Jelly, 3 bytes

RṙⱮ

Try it online!

Explanation

RṙⱮ  Monadic link, takes an argument z
R    [1, 2, ..., z-1, z]
  Ɱ  For each on right argument (z, defaults to loop over range)
 ṙ   Rotate the left list by the right amount

Alternative solution: +þ%. Generates the \$n\times n\$ addition table and then applies modulo to bring the elements into range.

Answer 3

R, 30 bytes

n=scan();outer(1:n,1:n,`+`)%%n

Try it online!

Answer 4

APL (dzaima/APL), 4 bytes

⌽ᐵ⍨⍳

⌽ rotate
ᐵ each left, apply each left element to the entire right argument
⍨ apply to both arguments
⍳ range

Try it online!

Answer 5

APL (Dyalog Unicode), 6 bytes

⍳⌽,⍨⍴⍳

Try it online!

There's already a nice 4-byter in dzaima/APL by rak1507, but I wanted to share a non-trivial short one in vanilla Dyalog. It is shorter than a modulo addition table ⊢|⍳∘.+⍳ and ties with the trivial port of rak's ⍳⌽¨∘⊂⍳.

Takes n and creates a flat matrix of numbers.

⍳⌽,⍨⍴⍳   ⍝ Input: n
  ,⍨     ⍝ [n, n]
    ⍴⍳   ⍝ Reshape [1..n] into an n×n matrix
         ⍝ For n = 4, this looks like this:
         ⍝ 1 2 3 4
         ⍝ 1 2 3 4
         ⍝ 1 2 3 4
         ⍝ 1 2 3 4
⍳⌽       ⍝ Rotate first row once, second row twice, ..., n-th row n times
         ⍝ 2 3 4 1
         ⍝ 3 4 1 2
         ⍝ 4 1 2 3
         ⍝ 1 2 3 4

Answer 6

Haskell, 32 bytes

f n=[[x..n]++[1..x-1]|x<-[1..n]]

Try it online!

A kind-of boring approach, just concatenates the ranges.

34 bytes

f n=[mod(k+div(-k)n)n|k<-[1..n*n]]

Try it online!

Outputs a flat list, zero-indexed, using the method from my Python answer. A slight adaptation is needing to make it work for [1..n*n] instead of [0..n*n-1].

Answer 7

J, 7 bytes

|i.+/i.

Try it online!

Creates an "addition table" of the range 0..n with itself i.+/i. and then takes the mod of each element by n |.

Answer 8

Julia 1.0, 19 bytes

!n=((N=1:n).+N').%n

Try it online!

Answer 9

Perl 5 -a, 34 bytes

$,=$";say$_.."@F",1..$_-1for 1..$_

Try it online!

Answer 10

jq, 20 bytes

range(.*.)*(1+1/.)%.

Try it online!

output is flattened

(my first jq answer)

Answer 11

Python 2, 40 bytes

lambda n:[(k+k/n)%n for k in range(n*n)]

Try it online!

Since the challenge allows a flat list of n*n outputs, we make do mapping k=0, 1, ... n*n-1 to the corresponding entry with (k+k/n)%n. We can get this by adding the row index k/n and column k%n and reducing modulo n, and removing the redundant inner %n. We could also do k*-~n/n%n.

Answer 12

Haskell, 37 35 bytes

Saved 2 bytes thanks to @Delfad0r Would have saved 5 bytes thanks to @AZTECCO (see xnor's answer)

f n=[mod(x+o)n|x<-[1..n],o<-[1..n]]

Try it online!

Answer 13

Retina, 22 bytes

.+
*
Y`\_`w
L$`.
$<'$`

Try it online! Explanation:

.+
*

Convert the input to unary.

Y`\_`w

Take the first n word characters (or use p for printable ASCII etc.)

L$`.
$<'$`

Create cycled rows. ($<' is the same as $&$'.)

Answer 14

Octave, 21 bytes

@(n,x=1:n)mod(x+x',n)

Try it online!

The same thing as many other answers...

-2 bytes by Giuseppe

Answer 15

Arturo, 33 bytes

$[n][map 0..(n*n)-1'x[(x+x/n)%n]]

Try it on the Arturo Playground! Note: it seems that editing the code edits it for everyone, so don't do that.

Answer 16

Wolfram Language (Mathematica), 23 bytes

+##&~Array~{#,#}~Mod~#&       

or (as @Roman suggested)

Plus~Array~{#,#}~Mod~#&

Try it online!

-2 bytes thanks to @att

Answer 17

yuno (abandoned), 4 bytes

ップア＠％

Explanation

ップ　　　　outer product table; for each (first) and for each (second)
　　ア　　　add
　　　＠　　swap top two
　　　　％　modulo

Can be written as ppua@%. Code is grouped as [ップ][ア][＠][％]. To prove this is actually 4 bytes, the bytecode is '~\x00ðó' (use the b flag to interpret code from bytecode).

Answer 18

Python 2, 43 bytes

lambda x,r=range:[r(i,x)+r(i)for i in r(x)]

Try it online!

Answer 19

Japt -m, 3 bytes

Output as a 2D array.

WéU

Try it

Or without the -m flag:

Japt, 4 bytes

ÆZéX

Try it

Answer 20

C (clang), ^{73 \$\cdots\$ 49} 46 bytes

Saved 3 bytes thanks to dingledooper!!!

a;f(n){for(a=n*n;a;)printf("%d ",--a*~n/n%n);}

Try it online!

Inputs \$n\$ and prints the Latin Square as a flat array consisting of \$n^2\$ values.

Answer 21

JavaScript (ES6), 46 bytes

n=>[...Array(n)].map((_,i,a)=>a.map(_=>i++%n))

Try it online!

---

JavaScript (ES6), 42 bytes

As pointed out by @tsh, returning a flatten array is shorter.

n=>[...Array(n*n)].map((_,i)=>(i/n+i)%n|0)

Try it online!

Answer 22

MATL, 3 bytes

5YL

Try it online!

          %implicit input n
5YL       % create circular matrix of size n

Equivalent to the following Octave/MATLAB code

Octave, 23 bytes

@(n)gallery('circul',n)

Try it online!

Alternately, this is equivalent to tsh's Octave answer.

MATL, 5 bytes

:&+G\

Try it online!

	% implicit input n
:	% range 1:n
&+	% add to itself transposed, with broadcast
G\	% push n and modulo n
	% implicit output

Answer 23

Scala, 44 bytes

n=>1 to n flatMap(_=>1 to n)sliding n take n

Try it in Scastie!

This is so simple it hardly needs an explanation, but here's one anyway:

n =>                     //The input
1 to n                   //Make a range of n numbers
  flatMap(_ => 1 to n)   //Map each to the range [1, n] and flatten
                         //This creates a list of n*n numbers
  sliding n              //Take n-sized chunks and move ahead by one each time
  take n                 //Keep the first n chunks

Answer 24

05AB1E, 4 bytes

LD._

Try it online!

LD._  # full program
  ._  # push...
L     # [1, 2, 3, ...,
      # ..., implicit input...
L     # ]...
  ._  # rotated to the left...
      # (implicit) each element in...
LD    # [1, 2, 3, ...,
      # ..., implicit input...
LD    # ]
      # implicit output

Answer 25

Japt, 7 bytes

o £o éX

Try it

o   - [0..U)
£   - map by:
o éX    > rotate X times [0..U)

Answer 26

PowerShell, 61 bytes

param($n)(0..($n*$n-1)|%{[math]::floor($_+$_/$n)%$n})-join" "

Try it online!

Answer 27

V (vim), ³⁸ 30 bytes

"aD@aO0<ESC>V{g<C-A>V}JqqYpdw$pq@a@qdk

Try it online!

Input as a single number.

Range creating script taken from Leo's Range, Reverse, Sum answer.

-8 bytes from Leo using J.

Fixed the problem with multidigit numbers.

Explanation

"aD@aO0<ESC>V{g<C-A>V}J
"aD                          delete first line and store in register a
   @aO0<ESC>                 print 0 on a newline a times
            V{g<C-A>         convert the zeroes to a range
                    V}J      select all, join with spaces

$xqqYp2x$pq@a@qdk
$x                           remove the last space
  qq                         start macro q:
    Yp                        duplicate current line
      dw                      remove first word (number + space)
        $p                    paste at the end
          q                  end macro
           @a@q              replay macro a times
               dk            delete last two extra iterations

Answer 28

Ruby, 33 bytes

->n{(0..n*n-1).map{|x|(x+x/n)%n}}

Try it online!

A lambda proc returning a flat array of n*n elements.

Answer 29

Java (JDK), 56 bytes

n->{for(int i=n*n;i-->0;)System.out.println((i/n+i)%n);}

Try it online!

Answer 30

Python 2, 79 bytes

n=input()
f=lambda b:f(b+b[-1:]+b[-n:-1])if len(b)<n*n else b
print f(range(n))

Try it online!