"""
4.1.1. Šestiboká kostka

Napište funkci, která bude vracet nově vygenerované náhodné číslo
simulující šestistěnnou kostku s čísly 1-6.
"""

from random import randint


def dice():
    return randint(1, 6)


print(dice(), dice(), dice())

"""
4.1.2. Dokud padá sudé číslo

Napište funkci, která bude provádět házení obyčejnou šestistěnnou kostkou
tak dlouho dokud nepadne liché číslo.
Poté funkce vrátí celkový součet všech hozených hodů.
"""


def turn():
    total = 0

    temp = dice()
    total += temp
    while temp % 2 == 0:
        temp = dice()
        total += temp
    return total


print(turn(), turn(), turn())

"""
4.1.4. Frekvence kostky

Napište funkci, která provede count hodů obyčejnou šestibokou kostkou
a následně vypíše kolikrát které číslo padlo.

Tip: pro ukládání frekvencí se mohou hodit seznamy z následující
kapitoly či nějaká jiná datová struktura.
"""


def dice_freq(count):
    stats = [0, 0, 0, 0, 0, 0]
    for _ in range(count):
        number = dice()
        stats[number - 1] += 1

    for i in range(6):
        print(str(i + 1) + ": " + str(stats[i]) + "x")


dice_freq(1000)

"""
4.2.1. Opilec na cestě domů

Opilec je na půli cesty mezi domovem a hospodou,
každý krok udělá náhodně jedním směrem.
Napište funkci, která bude simulovat opilcův pohyb.
Jejímy parametry budou vzdálenost mezi domovem a hospodou
a počet kroků do opilcova usnutí (tj. maximální délka simulace).
Simulace skončí buď tehdy, když opilec dojede domů nebo do hospody,
případně po vyčerpání počtu kroků.
"""


def print_path(size, position):
    print("home", end=" ")
    for i in range(size):
        if i == position:
            print("*", end=" ")
        else:
            print(".", end=" ")
    print("pub")


def drunkman_simulator(size, steps):
    if size < 3:
        print("Path too short")
        return
    position = int((size - 1) / 2)
    print_path(size, position)
    for _ in range(steps):
        direction = randint(1, 2)
        if direction == 1:
            position += 1
        else:
            position -= 1
        print_path(size, position)
        if position == size - 1:
            print("Ended in the pub again!")
            return
        elif position == 0:
            print("Got home!")
            return
    print("Fall asleep")


drunkman_simulator(10, 100)

"""
4.2.2. Analýza opilce

Pokud jste se zabývali otázkami položenými v předchozím příkladu,
zjistili jste, že to není až tak jednoduché zjistit.
V tomto příkladu tedy použijeme předchozí program pro jednoduchou analýzu,
jak to dopadne, když to zkusíme zopakovat vícekrát za sebou.

Nejprve upravte funkci z předchozí příkladu tak,
aby nevypisovala stav opilce (například přidáním volitelného
parametru output a zapodmínkováním výpisu) a aby vracela True
dojde-li opilec domů a False pokud ne.

Následně napište funkci, která provede simulaci opilce count krát
a vypíše procentuální úspěšnost dojití domů.
"""


def print_path(size, position):
    print("home", end=" ")
    for i in range(size):
        if i == position:
            print("*", end=" ")
        else:
            print(".", end=" ")
    print("pub")


def drunkman_simulator(size, steps, output=False):
    if size < 3:
        print("Path too short")
        return
    position = int((size - 1) / 2)
    if output:
        print_path(size, position)
    for _ in range(steps):
        direction = randint(1, 2)
        if direction == 1:
            position += 1
        else:
            position -= 1
        if output:
            print_path(size, position)
        if position == size - 1:
            if output:
                print("Ended in the pub again!")
            return False
        elif position == 0:
            if output:
                print("Got home!")
            return True


def drunkman_analysis(size, steps, count):
    times_home = 0
    for _ in range(count):
        if drunkman_simulator(size, steps):
            times_home += 1
    print("Arriving home in", float(times_home) * 100 / count, "% of cases")


drunkman_analysis(10, 100, 100)

"""
4.2.3. Hledač pokladů

Máme hledače pokladů, který hledá právě jeden ukrytý poklad
ve čtverci o hraně width polí.

Hledač začíná na pozici [0,0] a v každém kroku se pohne jedním ze 4 směrů
se stejnou pravděpodobností, pokud by měl vyjít ze čtverce, zůstává stát.

Napište funkci, která pro zadanou šířku width zjistí,
zdali v steps krocích hledač najde poklad.

Následně napište funkci, která provede předchozí funkci
pro zadané parametr count krát a vypíše,
jaká je pravděpodobnost nalezení pokladu.
"""


def treasure_hunter(width, steps):
    treasure = (randint(0, width - 1), randint(0, width - 1))
    x, y = 0, 0

    rounds = 0
    while treasure != (x, y) and rounds < steps:
        direction = randint(1, 4)
        if direction == 1 and x != 0:
            x -= 1
        elif direction == 2 and x != width - 1:
            x += 1
        elif direction == 3 and y != 0:
            y -= 1
        elif direction == 4 and y != width - 1:
            y += 1

        rounds += 1

    if treasure != (x, y):
        return False
    return True


def treasure_hunter_analysis(width, steps, count):
    successes = 0
    for _ in range(count):
        if treasure_hunter(width, steps):
            successes += 1
    print("Treasure found in", (float(successes) * 100) / count, "% of cases")


treasure_hunter_analysis(10, 100, 100)
# Treasure found in 45.9 % of cases

"""
4.2.6. Tipující student

Napište funkci, která experimentálně zjistí (pro count pokusů),
jaká je pravděpodobnost, že student natipuje alespoň polovinu
n otázkového testu, ve kterém každá otázka má právě 4 možnosti
a právě jedna z nich je správně.
"""


def random_student(n, count):
    correct_tests = 0
    for _ in range(count):
        correct_questions = 0
        for _ in range(n):  # Go through test
            correct = randint(1, 4)
            chosen = randint(1, 4)
            if correct == chosen:
                correct_questions += 1
        if correct_questions > n / 2:
            correct_tests += 1
    print("Probability of quessing at least 50 % of test is",
          (correct_tests * 100) / count, "%")


random_student(10, 100)