## cvičení 9
## 2D seznamy a hry

ARRAY = [
    [1, 2, 3, 1, 4],
    [1, 2, 2, 3, 3],
    [3, 2, 2, 3, 1],
    [1, 1, 2, 1, 1]
]


# ULOHA 1
# Funkce spočítá počet výskytů prvku <item> v matici.
# Funkce je čistá a nemění vstupní pole.
def count_items(array, item):
    pass


# vzorový výstup:
# >>> count_items(ARRAY, 1)
# 8
# >>> count_items(ARRAY, 3)
# 5

# ULOHA 2
# Funkce vytiskne index sloupce s největším součtem.
# Funkce je čistá a nemění vstupní pole.
def max_sum_col(array):
    pass


# vzorový výstup:
# >>> max_sum_col(ARRAY)
# 2


# ULOHA *3
# Funkce zjistí, zda se v poli nevyskytují dva prvky <item>
# vedle sebe. Bereme v potaz pouze horizontální a vertikální sousednost.
# Funkce je čistá a nemění vstupní pole.
def twins_items(array, item):
    pass

# vzorový výstup:
# >>> twins_items(ARRAY, 1)
# True
# >>> twins_items(ARRAY, 4)
# False


# ÚLOHA 4
# Napište funkci correct_parentheses(text). který zkontroluje, zda je
# text korektně uzávorkován.
# Řetězec je korektně uzávorkován právě tehdy, když buďto neobsahuje
# závorky žádné, nebo pro každou závorku v něm existuje taková
# opačná závorka, že řetězec uvnitř tohoto páru závorek je korektně
# uzávorkován.
#
# V této úloze budeme uvažovat následující typy závorek:
#
#  • kulaté závorky: otevírací ‹(› a uzavírací ‹)›,
#  • hranaté závorky ‹[›, ‹]›, a konečně
#  • složené závorky ‹{›, ‹}›.
#
# Použijte strukturu zásobník.
def correct_parentheses(text):
    pass


# vzorový výstup
# >>> correct_parentheses("abc")
# True
# >>> correct_parentheses("([])")
# True
# >>> correct_parentheses("python()py[tho{n}]{{()}}")
# True
# >>> not correct_parentheses("([)]")
# False
# >>> correct_parentheses("p{y}[t]ho(n[]))")
# False


# ÚLOHA *5
# Napište program, který pro dané souřadnice <coordinates>.
# vyplní všechny sousední pixely se stejnou hodnotou <original_value>
# číslem <value>. Přebarvení hodnoty by se mělo propagovat obrazem
# dokud bude existovat nějaký soused přebarveného čísla s hodnotou
# <original_value>.
# K implementaci využijte zásobník, nebo frontu.
# Ošetřete vhodně případ, kdy <value> == <original_value>
def fill_area(image, coordinates, value):
    pass

# vzorový výstup:
# >>> image = [[2, 0, 1],
#              [0, 0, 1],
#              [0, 1, 1]]
# >>> fill_area(image, (1, 0), 3)
# >>> image
# [[2, 3, 1],
#  [3, 3, 1],
#  [3, 1, 1]]
# >>> fill_area(image, (0, 0), 3)
# >>> image
# [[3, 3, 1],
#  [3, 3, 1],
#  [3, 1, 1]]
# >>> fill_area(image, (2, 2), 0)
# >>> image
# [[3, 3, 0],
#  [3, 3, 0],
#  [3, 0, 0]]


# ÚLOHA 6
# Cílem úlohy je vytvořit implementaci hry tic-tac-toe.
# K řešení využijte následující kód.
#
# a) Okomentujte již existující funkce.
# b) Najděte chyby a opravte funkcionalitu hry.
# c) Vytvořte přívětivější uživatelské rozhraní. Hra by měla být stabilní
#    proti příkazům hráče, hráč by měl být informován jak hrát.
N = 3


def empty_plan():
    return [[0 for _ in range(N)]
            for _ in range(N)]


def determine_winner(plan):
    for i in range(N):
        all_same = True
        for j in range(N):
            if plan[i][j] != plan[i][0]:
                all_same = False
        if all_same and plan[i][0] != 0:
            return plan[i][0]

        all_same = True
        for j in range(N):
            if plan[j][i] != plan[0][i]:
                all_same = False
        if all_same and plan[0][i] != 0:
            return plan[0][i]
    return 0


def print_plan(plan):
    symbol = {0: ".", 1: "X", 2: "O"}
    for i in range(N):
        for j in range(N):
            print(symbol[plan[i][j]], end=" ")
        print()


def play():
    plan = empty_plan()
    player = 1
    while determine_winner(plan) == 0:
        print_plan(plan)
        move = input("Player " + str(player) + " move:")
        x, y = list(map(int, move.split(" ")))
        plan[y - 1][x - 1] = player
        player = 3 - player
    print_plan(plan)
    print("Player " + str(determine_winner(plan)) + " wins.")


if __name__ == "__main__":
    # zde můžete volat implementované funkce a zkusit si, jak fungují
    # play()
    pass
