1. # Poprawione, z możliwością zmiany ilości kart bez edytowania kodu, zapytanie przy uruchamianiu programu
2. # W celu analizay własnej, skopiuj wyniki programu do kolumny w excelu i stwórz wykres punktowy z tymi danymi
3.  
4. import random as rand
5. import pprint
6.  
7. pp = pprint.PrettyPrinter(indent=4, width=60, compact=True)
8.  
9. def generate_card_stack(s, r, ordered):
10.     if ordered:
11.         card_stack = list(range(1, s+1))
12.     else:
13.         card_stack = rand.sample(range(1,r+1),s)
14.     return card_stack
15.    
16. def get_average_from_list(lst):
17.     return sum(lst) / len(lst)  
18.    
19. def get_average_distanses(stack):
20.     distanses = []
21.     for num, card in enumerate(stack[:-1]):
22.         distanses.append(abs(stack[num+1]-card))
23.     return get_average_from_list(distanses)
24.    
25. def check_entropy(stack, s, r):
26.     rand_stack = generate_card_stack(s, r, False)
27.     d = get_average_distanses(rand_stack)
28.     ds = get_average_distanses(stack)
29.     return abs(ds-d)
30.    
31. def divide_for_small_stacks(stack, qtty):
32.     small_stacks =  [[] for i in range(0,qtty)]
33.     for num, card in enumerate(stack):
34.         small_stacks[num%qtty].append(card)
35.     return small_stacks
36.    
37. def get_random_stack(stck, stack_qtty):    
38.     r = rand.randint(0, stack_qtty)%len(stck)
39.     s = stck[r]
40.     return [s, r]
41.    
42.    
43. def stack_on_stack(stacks, stack_qtty):
44.     while True:
45.         stcks = stacks
46.         s = get_random_stack(stcks, stack_qtty)
47.         first_stack = s[0]
48.         r = s[1]
49.         if len(stcks)>1:
50.             stcks.pop(r)
51.             s = get_random_stack(stcks, stack_qtty)
52.             second_stack = s[0]
53.             r = s[1]
54.             stcks[r] = second_stack + first_stack
55.         else:
56.             break
57.     return stcks
58.    
59.    
60. def shuffle(s, r, stack_qtty, stack):
61.     stacks = divide_for_small_stacks(stack, stack_qtty)
62.     stacks = stack_on_stack(stacks, stack_qtty)
63.     return stacks[0]
64.    
65.    
66. def main():
67.    
68.     simulation = 1000
69.     rounds = 1
70.     stack_decrease = 0
71.     stack_qtty = 1
72.     s = int(input('Cards in deck '))
73.     r = s # card types
74.     rounds = int(input('Rounds: '))
75.     stack_qtty = int(input('Stack quantity: '))
76.     print('')
77.    
78.    
79.     control_entropy = []
80.     shuffle_entropy = []
81.     rand_entropy = []
82.     stack = generate_card_stack(s, r, True)
83.     ord_stack = generate_card_stack(s, r, True)
84.     while simulation>0:
85.         stack = generate_card_stack(s, r, True)
86.         while rounds>0:  
87.             shuffled_stack = shuffle(s, r, stack_qtty, stack)
88.             stack = shuffled_stack
89.             rounds-=1
90.        
91.         control_entropy.append(check_entropy(ord_stack, s, r))
92.         shuffle_entropy.append(check_entropy(shuffled_stack, s, r))
93.         rand_stack = generate_card_stack(s, r, False)
94.         rand_entropy.append(check_entropy(rand_stack, s, r))
95.         simulation -=1
96.        
97.     #pp.pprint(rand_stack)
98.     #print()
99.     #pp.pprint(shuffled_stack)
100.    
101.     for s in shuffled_stack:
102.         print(s)
103.     #for ra in rand_stack:
104.     #    print(ra)
105.     #pp.pprint(shuffled_stack)
106.     pp.pprint(rand_stack)
107.     print("ordered vs random: ", get_average_from_list(control_entropy))
108.     print("shuffled vs random: ", get_average_from_list(shuffle_entropy))
109.     print("random vs random: ", get_average_from_list(rand_entropy))
110.     #print("shuffled vs random max: ", max(shuffle_entropy))
111.     #print("shuffled vs random min: ", min(shuffle_entropy))
112.    
113.    
114.  
115. main()