square = [
    [1, 6, 8, 0],
    [7, 2, 6, 1],
    [3, 3, 4, 4],
    [5, 9, 0, 3],
]

rectangle = [
    [0, 6, 3, 6, 7],
    [8, 2, 4, 7, 9],
    [5, 3, 1, 6, 5],
]


# funkce vrati pocet 0 v tabulce
def count_zeros(table):
    pass


def test_count_zeros():
    assert count_zeros(square) == 2
    assert count_zeros(rectangle) == 1


# test_count_zeros()


# funkce vrati seznam obsahujici ity sloupec
# funkce nesmi modifikovat predanou tabulku
def get_column(table, i):
    pass


def test_get_column():
    assert get_column(square, 0) == [1, 7, 3, 5]
    assert get_column(square, 1) == [6, 2, 3, 9]
    assert get_column(rectangle, 2) == [3, 4, 1]
    assert get_column(rectangle, 4) == [7, 9, 5]


# test_get_column()


# funkce vrati index sloupce s nejvetsim souctem
def max_sum_column_index(table):
    pass


def test_max_sum_index():
    assert max_sum_column_index(square) == 1
    assert max_sum_column_index(rectangle) == 4


# test_max_sum_index()


# funkce vypise cisla na diagonale predane tabulky
def print_diagonal(table):
    pass


def test_print_diagonal():
    print_diagonal(square)  # 1 2 4 3
    print_diagonal(rectangle)  # 0 2 1


# test_print_diagonal()


# funkce vrati dvojici se souradnicemi nejvetsiho prvku v tabulce
# v poradi sloupec, radek; souradnice 0, 0 jsou v levem hornim rohu a rostou
# dolu a doprava
def max_elem_coords(table):
    pass


def test_max_elem_coords():
    assert max_elem_coords(square) == (1, 3)
    assert max_elem_coords(rectangle) == (4, 1)


# test_max_elem_coords()


# funkce vrati transponovanou tabulku (radky misto sloupcu, sloupce misto radku)
# funkce nesmi upravovat predanou tabulku
def transpose(table):
    pass


def test_transpose():
    assert transpose(square) == [
        [1, 7, 3, 5],
        [6, 2, 3, 9],
        [8, 6, 4, 0],
        [0, 1, 4, 3],
    ]
    assert transpose(rectangle) == [
        [0, 8, 5],
        [6, 2, 3],
        [3, 4, 1],
        [6, 7, 6],
        [7, 9, 5],
    ]


# test_transpose()


# funkce vrati seznam cisel, ktera sousedi s cislem v danem radku a sloupci
# (indexovano od 0 z leveho horniho rohu), v libovolnem poradi
def get_neighbors(table, row, col):
    pass


def test_get_neighbors():
    assert sorted(get_neighbors(square, 1, 1)) == [3, 6, 6, 7]
    assert sorted(get_neighbors(square, 2, 1)) == [2, 3, 4, 9]
    assert sorted(get_neighbors(square, 1, 0)) == [1, 2, 3]
    assert sorted(get_neighbors(square, 3, 2)) == [3, 4, 9]
    assert sorted(get_neighbors(square, 0, 3)) == [1, 8]


# funkce vraci true prave tehdy, kdyz tabulka obsahuje dve stejna cisla vedle
# sebe nebo nad sebou ("sdilejici hranu")
def same_neighbors(table):
    pass


def test_same_neighbors():
    assert same_neighbors(square)
    assert not same_neighbors(rectangle)


# Při běžném počítání s aritmetickými výrazy 6 + 5 používáme takzvanou infixovou
# notaci s operátorem mezi operandy. V tomto příkladě budeme pracovat s takzvaně
# reverzní polskou notací, kdy operátor následuje po operandech, například 6 5 *.
# Vyzkoušejte si převést 7 * 8 + 2 * 6 + 5 do postfixu a následně si ho zkuste
# spolu s 5 7 * 3 - 4 + vyhodnotit.
# Napište funkci, která obdrží řetězec v postfixové notaci a ta výraz za pomocí
# zásobníku vyhodnotí. Implementuje operace +, -, / a * v plovoucí čárce.
# Tip: může se vám hodit metoda split, která je použitelná na řetězcích:
# "a b c".split().
def evaluate_postfix(expr):
    pass


def test_evaluate_postfix():
    assert evaluate_postfix("8 7 * 6 5 + 2 * +") == 78
    assert evaluate_postfix("6 5 -") == 1
    assert evaluate_postfix("15 7 1 1 + - / 3 * 2 1 1 + + -") == 5


# test_evaluate_postfix()


# Napište funkci next_greater, která pro seznam lst vrátí seznam n-tic (e, ng),
# kde e je prvek ze seznamu lst a ng je další prvek, který je větší než e. Když
# se v seznamu nenachází větší prvek, použijte None.
# Ve výsledném seznamu se musí nacházet všechny prvky z předaného seznamu, na
# pořadí nezáleží.
def next_greater(lst):
    pass


def test_next_greater() -> None:
    assert set(next_greater([4, 5, 2, 25])) == {(4, 5), (5, 25), (2, 25), (25, None)}
    assert set(next_greater([13, 7, 6, 12])) == {
        (13, None),
        (7, 12),
        (6, 12),
        (12, None),
    }
    assert set(next_greater([11, 13, 21, 3])) == {
        (11, 13),
        (13, 21),
        (21, None),
        (3, None),
    }


MORSE_CODE = {
    "A": ".-",
    "B": "-...",
    "C": "-.-.",
    "D": "-..",
    "E": ".",
    "F": "..-.",
    "G": "--.",
    "H": "....",
    "I": "..",
    "J": ".---",
    "K": "-.-",
    "L": ".-..",
    "M": "--",
    "N": "-.",
    "O": "---",
    "P": ".--.",
    "Q": "--.-",
    "R": ".-.",
    "S": "...",
    "T": "-",
    "U": "..-",
    "V": "...-",
    "W": ".--",
    "X": "-..-",
    "Y": "-.--",
    "Z": "--..",
    "1": ".----",
    "2": "..---",
    "3": "...--",
    "4": "....-",
    "5": ".....",
    "6": "-....",
    "7": "--...",
    "8": "---..",
    "9": "----.",
    "0": "-----",
}


# funkce na prevod do morseovy abecedy
def encode(value):
    pass


# funkce na prevod z morseovy abecedy
def decode(value):
    pass


def test_encode() -> None:
    assert encode("SOS") == "... --- ..."
    assert encode("HELLOWORLD") == ".... . .-.. .-.. --- .-- --- .-. .-.. -.."


def test_decode() -> None:
    assert decode(".... . .-.. .-.. --- .-- --- .-. .-.. -..") == "HELLOWORLD"
    assert decode(encode("IDENTITY")) == "IDENTITY"


# Napište funkci, která zkontroluje, zda předaný seznam obsahuje jen unikátní čísla.
def unique_check(temp):
    pass


def test_unique_check():
    assert not unique_check([1, 5, 6, 5, 4, 9])
    assert unique_check([1, 5, 6, 3, 9])


################################################################################
################################################################################
#######                                                                  #######
####### S resenim nasledujiciho prikladu vyckejte na pokyn od cvicicich. #######
#######                                                                  #######
################################################################################
################################################################################

N = 3


def empty_plan():
    return [["." for i in range(N)] for j 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] != ".":
            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] != ".":
            return plan[0][i]
    return "."


def print_plan(plan):
    for row in range(N):
        for col in range(N):
            print(plan[row][col], end=" ")
        print()


def get_coords(player):
    move = input("Player " + player + " move: ")
    raw_row, raw_col = move.split(" ")
    row, col = int(raw_row), int(raw_col)
    return row - 1, col - 1


def play():
    plan = empty_plan()
    player = "O"

    while determine_winner(plan) == ".":
        print_plan(plan)
        row, col = get_coords(player)
        plan[row][col] = player
        player = "X" if player == "O" else "O"

    print_plan(plan)
    print("Player " + determine_winner(plan) + " wins.")


# play()