I'm new to Python, and have some problems with creating random lists.
I'm using random.sample(range(x, x), y).
I want to get 4 lists with unique numbers, from 1-4, so I have been using this
a = random.sample(range(1, 5), 4) b = random.sample(range(1, 5), 4) c = random.sample(range(1, 5), 4) d = random.sample(range(1, 5), 4) So I get for example
a = 1, 3, 2, 4 b = 1, 4, 3, 2 c = 2, 3, 1, 4 d = 4, 2, 3, 1 How can I make it that the column are also unique?
Absent a clear mathematical theory, I distrust anything other than a somewhat hit-and-miss approach. In particular, backtracking approaches can introduce a subtle bias:
from random import shuffle def isLatin(square): #assumes that square is an nxn list #where each row is a permutation of 1..n n = len(square[0]) return all(len(set(col)) == n for col in zip(*square)) def randSquare(n): row = [i for i in range(1,1+n)] square = [] for i in range(n): shuffle(row) square.append(row[:]) return square def randLatin(n): #uses a hit and miss approach while True: square = randSquare(n) if isLatin(square): return square Typical output:
>>> s = randLatin(4) >>> for r in s: print(r) [4, 1, 3, 2] [2, 3, 4, 1] [1, 4, 2, 3] [3, 2, 1, 4] 
Totally random then:
def gen_matrix(): first_row = random.sample(range(1, 5), 4) tmp = first_row + first_row rows = [] for i in range(4): rows.append(tmp[i:i+4]) return random.sample(rows, 4) 
Create a list of all the elements, and as will filling the line, remove the used element.
import random def fill_line(length): my_list = list(range(length)) to_return = [] for i in range(length): x = random.choice(my_list) to_return.append(x) my_list.remove(x) return to_return x = [fill_line(4) for i in range(4)] print(x) Probably the simplest way is to create a valid matrix, and then shuffle the rows, and then shuffle the columns:
import random def random_square(U): U = list(U) rows = [U[i:] + U[:i] for i in range(len(U))] random.shuffle(rows) rows_t = [list(i) for i in zip(*rows)] random.shuffle(rows_t) return rows_t Usage:
>>> random_square(range(1, 1+4)) [[2, 3, 4, 1], [4, 1, 2, 3], [3, 4, 1, 2], [1, 2, 3, 4]] This should be able to create any valid matrix with equal probability. After doing some reading it seems that this still has bias, although I don't fully comprehend why yet.
I would build a random latin square by 1) start with a single random permutation, 2) populate the rows with rotations 3) shuffle the rows 4) transpose the square 5) shuffle the rows again:
from collections import deque from random import shuffle def random_latin_square(elements): elements = list(elements) shuffle(elements) square = [] for i in range(len(elements)): square.append(list(elements)) elements = elements[1:] + [elements[0]] shuffle(square) square[:] = zip(*square) shuffle(square) return square if __name__ == '__main__': from pprint import pprint square = random_latin_square('ABCD') pprint(square) 