# Poprawione, z możliwością zmiany ilości kart bez edytowania kodu, zapytanie przy uruchamianiu programu
# W celu analizay własnej, skopiuj wyniki programu do kolumny w excelu i stwórz wykres punktowy z tymi danymi
 
import random as rand
import pprint
 
pp = pprint.PrettyPrinter(indent=4, width=60, compact=True)
 
def generate_card_stack(s, r, ordered):
    if ordered:
        card_stack = list(range(1, s+1))
    else:
        card_stack = rand.sample(range(1,r+1),s)
    return card_stack
   
def get_average_from_list(lst):
    return sum(lst) / len(lst)  
   
def get_average_distanses(stack):
    distanses = []
    for num, card in enumerate(stack[:-1]):
        distanses.append(abs(stack[num+1]-card))
    return get_average_from_list(distanses)
   
def check_entropy(stack, s, r):
    rand_stack = generate_card_stack(s, r, False)
    d = get_average_distanses(rand_stack)
    ds = get_average_distanses(stack)
    return abs(ds-d)
   
def divide_for_small_stacks(stack, qtty):
    small_stacks =  [[] for i in range(0,qtty)]
    for num, card in enumerate(stack):
        small_stacks[num%qtty].append(card)
    return small_stacks
   
def get_random_stack(stck, stack_qtty):    
    r = rand.randint(0, stack_qtty)%len(stck)
    s = stck[r]
    return [s, r]
   
   
def stack_on_stack(stacks, stack_qtty):
    while True:
        stcks = stacks
        s = get_random_stack(stcks, stack_qtty)
        first_stack = s[0]
        r = s[1]
        if len(stcks)>1:
            stcks.pop(r)
            s = get_random_stack(stcks, stack_qtty)
            second_stack = s[0]
            r = s[1]
            stcks[r] = second_stack + first_stack
        else:
            break
    return stcks
   
   
def shuffle(s, r, stack_qtty, stack):
    stacks = divide_for_small_stacks(stack, stack_qtty)
    stacks = stack_on_stack(stacks, stack_qtty)
    return stacks[0]
   
   
def main():
   
    simulation = 1000
    rounds = 1
    stack_decrease = 0
    stack_qtty = 1
    s = int(input('Cards in deck '))
    r = s # card types
    rounds = int(input('Rounds: '))
    stack_qtty = int(input('Stack quantity: '))
    print('')
   
   
    control_entropy = []
    shuffle_entropy = []
    rand_entropy = []
    stack = generate_card_stack(s, r, True)
    ord_stack = generate_card_stack(s, r, True)
    while simulation>0:
        stack = generate_card_stack(s, r, True)
        while rounds>0:  
            shuffled_stack = shuffle(s, r, stack_qtty, stack)
            stack = shuffled_stack
            rounds-=1
       
        control_entropy.append(check_entropy(ord_stack, s, r))
        shuffle_entropy.append(check_entropy(shuffled_stack, s, r))
        rand_stack = generate_card_stack(s, r, False)
        rand_entropy.append(check_entropy(rand_stack, s, r))
        simulation -=1
       
    #pp.pprint(rand_stack)
    #print()
    #pp.pprint(shuffled_stack)
   
    for s in shuffled_stack:
        print(s)
    #for ra in rand_stack:
    #    print(ra)
    #pp.pprint(shuffled_stack)
    pp.pprint(rand_stack)
    print("ordered vs random: ", get_average_from_list(control_entropy))
    print("shuffled vs random: ", get_average_from_list(shuffle_entropy))
    print("random vs random: ", get_average_from_list(rand_entropy))
    #print("shuffled vs random max: ", max(shuffle_entropy))
    #print("shuffled vs random min: ", min(shuffle_entropy))
   
   
 
main()