पायथन यादृच्छिक सूची

Question

मैं पाइथन के लिए नया हूं, और यादृच्छिक सूचियां बनाने में कुछ समस्याएं हैं।

मैं random.sample(range(x, x), y) का उपयोग कर रहा हूं।

मैं 1-4 से अद्वितीय संख्या के साथ 4 सूचियों, प्राप्त करना चाहते हैं, तो मैं उपयोग कर रहा है इस

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) 

तो मैं उदाहरण

a = 1, 3, 2, 4 
b = 1, 4, 3, 2 
c = 2, 3, 1, 4 
d = 4, 2, 3, 1 

के लिए मिलता है मैं इसे कैसे कर सकते हैं कि कॉलम भी अद्वितीय हैं?

Answer 1

शायद सबसे आसान तरीका है एक वैध मैट्रिक्स बनाने के लिए, और फिर पंक्तियों शफ़ल, और फिर कॉलम शफ़ल है:

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 

उपयोग:

>>> random_square(range(1, 1+4)) 
[[2, 3, 4, 1], [4, 1, 2, 3], [3, 4, 1, 2], [1, 2, 3, 4]] 

इस बनाने के लिए सक्षम होना चाहिए बराबर संभावना के साथ कोई मान्य मैट्रिक्स। कुछ पढ़ने के बाद ऐसा लगता है कि इसमें अभी भी पूर्वाग्रह है, हालांकि मैं अभी तक पूरी तरह से समझ नहीं पा रहा हूं।

Answer 2

सभी तत्वों की एक सूची बनाएं, और लाइन भरने के रूप में, प्रयुक्त तत्व को हटा दें।

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) 

Answer 3

एक स्पष्ट गणितीय सिद्धांत अनुपस्थित है, मैं कुछ हद तक हिट-एंड-मिस दृष्टिकोण के अलावा कुछ भी अविश्वास करता हूं।

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 

ठेठ उत्पादन:

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

Answer 4

पूरी तरह से तो यादृच्छिक:

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) 

Answer 5

मैं 1 से एक यादृच्छिक लैटिन वर्ग का निर्माण होगा) शुरू विशेष रूप से, दृष्टिकोण उलटे पांव लौटने से एक सूक्ष्म पूर्वाग्रह लागू कर सकते हैं एक यादृच्छिक क्रमपरिवर्तन के साथ, 2) पंक्तियों के साथ पंक्तियों को पॉप्युलेट करें 3) पंक्तियों को घुमाएं 4) वर्ग 5 को स्थानांतरित करें) पंक्तियों को फिर से घुमाएं:

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)