def multiply(a, b):
    """Dokončete funkci, která přijímá dvě celá čísla a vrací
    součin jejich jednotkových číslic.
    Předpokládejme, že vstup je vždy platný.
    Příklady:
    multiply(148, 412) by mělo vrátit 16.
    multiply(19, 28) by mělo vrátit 72.
    multiply(2020, 1851) by mělo vrátit hodnotu 0.
    multiply(14,-15) by mělo vrátit 20.
    """

def multiply(a, b):
    """Dokončete funkci, která vezme dvě celá čísla a vrátí
    součin jejich jednotkových číslic.
    Předpokládejme, že vstup je vždy platný.
    Příklady:
    multiply(148, 412) should return 16.
    multiply(19, 28) should return 72.
    multiply(2020, 1851) should return 0.
    multiply(14,-15) should return 20.
    """

def multiply(a, b):
    """Přijměte dvě celá čísla a dokončete funkci, která vrátí součin číslic na místě jednotek každého čísla.
    Předpokládejte, že vstup je vždy platný.
    Příklad:
    multiply(148, 412) by mělo vrátit 16.
    multiply(19, 28) by mělo vrátit 72.
    multiply(2020, 1851) by mělo vrátit 0.
    multiply(14,-15) by mělo vrátit 20.
    """


def count_upper(s):
    """
    Daný řetězec s, spočítejte počet velkých samohlásek na sudých indexech.

    Příklad:
    count_upper('aBCdEf') vrátí 1
    count_upper('abcdefg') vrátí 0
    count_upper('dBBE') vrátí 0
    """

def count_upper(s):
    """
    Je-li dán řetězec s, spočítejte počet velkých samohlásek v sudých indexech.

    Například:
    count_upper('aBCdEf') vrátí 1
    count_upper('abcdefg') vrátí 0
    count_upper('dBBE') vrátí 0
    """

def count_upper(s):
    """ Vzhledem k řetězci s spočítejte počet velkých samohlásek v sudých indexech.

    Například:
    count_upper('aBCdEf') vrátí 1
    count_upper('abcdefg') vrátí 0
    count_upper('dBBE') vrátí 0
    """


def closest_integer(value):
    '''
    Vytvořte funkci, která přijme hodnotu reprezentující číslo (řetězec) a
    vrátí nejbližší celé číslo.
    Pokud je číslo stejně vzdálené od dvou celých čísel, zaokrouhlete směrem od 0.

    Příklady
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Poznámka:
    Zaokrouhlování směrem od 0 znamená, že když je dané číslo stejně vzdálené od dvou celých čísel,
    celé číslo, které je třeba vrátit, je to, které je nejdále od 0. Například, closest_integer("14.5") by mělo
    vrátit 15, a closest_integer("-14.5") by mělo vrátit -15.
    '''

def closest_integer(value):
    '''
    Vytvoření funkce, která přebírá hodnotu (řetězec) představující číslo
    a vrátí k němu nejbližší celé číslo. Pokud je číslo ve stejné vzdálenosti
    ze dvou celých čísel jej zaokrouhlete směrem od nuly.

    Příklady
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Poznámka:
    Zaokrouhlení od nuly znamená, že pokud je dané číslo ve stejné vzdálenosti
    ze dvou celých čísel byste měli vrátit to, které je
    nejdále od nuly. Například closest_integer("14.5") by měl
    Vrátí hodnotu 15 a closest_integer("-14,5") by mělo vrátit hodnotu -15.
    '''

def closest_integer(value):
    '''
    Vytvoření funkce, která bere hodnotu (řetězec) reprezentující číslo
    a vrátí nejbližší celé číslo k němu. Pokud je číslo rovnocenné vzdálenosti
    ze dvou celých čísel, zaokrouhlit ji od nuly.

    Příklady
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Poznámka:
    Zaokrouhlení od nuly znamená, že pokud je dané číslo stejně vzdálené
    ze dvou celých čísel byste měli vrátit to, které je
    nejdále od nuly. Například closest_integer("14.5") by mělo
    return 15 a closest_integer("-14.5") by měly vrátit -15.
    '''


def make_a_pile(n):
    """
    Pokud je kladné celé číslo n, musíte vytvořit hromadu n úrovní kamenů.
    První úroveň má n kamenů.
    Počet kamenů v další úrovni je:
        - další liché číslo, pokud je n liché.
        - další sudé číslo, je-li n sudé.
    Vraťte počet kamenů v každé úrovni v seznamu, kde prvek na indexu
    i představuje počet kamenů v úrovni (i+1).

    Příklady:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Pro kladné celé číslo n, musíte vytvořit hromádku n úrovní kamenů.
    První úroveň má n kamenů.
    Počet kamenů v další úrovni je:
        - další liché číslo, pokud n je liché.
        - další sudé číslo, pokud je n sudé.
    Vrátí počet kamenů v každé úrovni v seznamu, kde element na indexu i představuje počet kamenů v úrovni (i+1).

    Příklady:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Obdržíte řetězec slov oddělených čárkou nebo mezerou.
    Vaším úkolem je rozdělit řetězec na slova a vrátit pole slov.

    Příklad:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Dostanete řetězec slov oddělených čárkami nebo mezerami. Vaším úkolem je
    rozdělit řetězec na slova a vrátit pole slov.

    Například:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """
    """


def choose_num(x, y):
    """Tato funkce přijímá dvě kladná čísla x a y a vrací největší sudé celé číslo v rozsahu [x, y].
    Pokud takové číslo neexistuje, funkce musí vrátit -1.

    Příklad:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Tato funkce vezme dvě kladná čísla x a y a vrátí
    největší sudé celé číslo, které je v rozsahu [x, y] včetně. Li
    takové číslo neexistuje, pak by funkce měla vrátit -1.

    Například:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Tato funkce vezme dvě kladná čísla x a y a vrátí hodnotu
    největší sudé celé číslo v rozsahu [x, y] včetně. Když
    Žádné takové číslo neexistuje, pak by funkce měla vrátit -1.

    Například:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Dostanete dvě kladná celá čísla n a m a vaším úkolem je vypočítat
    průměr celých čísel od n do m (včetně n a m).
    Zaokrouhlete odpověď na nejbližší celé číslo a převeďte ji na binární.
    Pokud je n větší než m, vrátí se -1.
    Příklad:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Jsou vám dána dvě kladná celá čísla n a m a vaším úkolem je vypočítat
    průměr celých čísel od n do m (včetně n a m).
    Zaokrouhlete výsledek na nejbližší celé číslo a převeďte ho na binární.
    Pokud je n větší než m, vrátí hodnotu -1.
    Příklad:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Když jsou dána dvě kladná celá čísla n a m, úkolem je vypočítat průměr celých čísel od n do m
    (včetně n a m). Zaokrouhlit výsledek na nejbližší celé číslo a převést tuto hodnotu na binární.
    Pokud je n větší než m, vrátit -1.
    Příklad:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Zadaný seznam kladných celých čísel x vrátí seřazený seznam všech
    prvků, které nemají žádnou sudou číslici.

    Poznámka: Vrácený seznam by měl být seřazen ve vzestupném pořadí.

    Například:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Vzhledem k seznamu kladných celých čísel x. vrátí seřazený seznam všech
    prvky, které nemají žádnou sudou číslici.

    Poznámka: Vrácený seznam by měl být seřazen ve vzestupném pořadí.

    Například:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Seznam kladných celých čísel x je dán, vrátí všechny prvky, které neobsahují
    sudé číslice ve formě seřazeného seznamu.

    Poznámka: Vrácený seznam musí být seřazen ve vzestupném pořadí.

    Příklad:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Pokud je zadáno pole celých čísel, seřaďte celá čísla mezi 1 a 9 včetně,
    poté otočte výsledné pole a nahraďte každé číslo odpovídajícím názvem "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Příklad:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> seřadit arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> otočit arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Pokud je pole prázdné, vrátit prázdné pole:
      arr = []
      return []

      Pokud je v poli neznámé číslo, ignorujte ho:
      arr = [1, -1 , 55]
            -> seřadit arr -> [-1, 1, 55]
            -> otočit arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Vzhledem k poli celých čísel seřaďte celá čísla mezi 1 a 9 včetně,
    obrátit výsledné pole a poté nahradit každou číslici odpovídajícím názvem z
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Například:
    arr = [2, 1, 1, 4, 5, 8, 2, 3]
          -> sort arr-> [1, 1, 2, 2, 3, 4, 5, 8]
          -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
     return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

    Pokud je pole prázdné, vraťte prázdné pole:
    arr = []
    vrátit []

    Pokud má pole nějaké podivné číslo, ignorujte ho:
    arr = [1, -1, 55]
          ->sort arr -> [-1, 1, 55]
          -> reverse arr -> [55, 1, -1]
    return = ['One']
     """

def by_length(arr):
    """
    Zadané pole celých čísel, seřaďte celá čísla mezi 1 a 9 včetně,,
    otočit výsledné pole a poté nahradit každou číslici odpovídajícím názvem z
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Například:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      návrat ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Pokud je pole prázdné, vraťte prázdné pole:
      arr = []
      return []

      Pokud má pole nějaké podivné číslo, ignorujte ho:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Implementace funkce f. Tato funkce přijímá n jako parametr a
    vrací seznam o velikosti n. Hodnota prvku na indexu i je faktoriál i, pokud je i sudé,
    jinak je to součet čísel od 1 do i.
    i začíná od 1.
    Faktoriál i je součin čísel od 1 do i (1 * 2 * ... * i).
    Příklad:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implementujte funkci f, která bere n jako parametr,
    a vrátí seznam velikosti n, takže hodnota prvku na indexu i je faktoriál i, pokud je i sudé
    nebo součet čísel od 1 do i jinak.
    začínám od 1.
    faktoriál i je násobení čísel od 1 do i (1 * 2 * ... * i).
    Příklad:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Když je dáno kladné celé číslo n, vraťte dvojici obsahující počet sudých a lichých palindromických čísel v rozsahu (1, n).

    Příklad 1:

        Vstup: 3
        Výstup: (1, 2)
        Vysvětlení:
        Palindromická čísla jsou 1, 2, 3. Z toho je jedno sudé a dvě lichá.

    Příklad 2:

        Vstup: 12
        Výstup: (4, 6)
        Vysvětlení:
        Palindromická čísla jsou 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Z toho jsou čtyři sudá a šest lichých.

    Odkazy:
        1. 1 <= n <= 10^3
        2. Vrácená dvojice obsahuje počet sudých a lichých palindromických čísel.
    """

def even_odd_palindrome(n):
    """
    Vzhledem k kladnému celému číslu n vraťte n-tici, která má počet sudých a lichých
    celočíselné palindromy, které spadají do rozsahu (1, n), včetně.

    Příklad 1:

        Vstup: 3
        Výstup: (1, 2)
        Vysvětlení:
        Celočíselný palindrom je 1, 2, 3. jeden z nich je sudý a dva z nich jsou liché.

    Epříklad 2:

        Vstup: 12
        Výstup: (4, 6)
        Vysvětlení:
        Celočíselné palindromy jsou 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. čtyři z nich jsou sudé a 6 z nich je lichých.

    Poznámka:
        1. 1 <= n <= 10^3
        2. vrácená n-tice má počet sudých a lichých celočíselných palindromů.
    """

def even_odd_palindrome(n):
    """
    Dáné kladné celé číslo n, vraťte n-tici, která obsahuje počet sudých a lichých celočíselných palindromů v rozsahu (1, n), včetně.

    Příklad 1:

        Vstup: 3
        Výstup: (1, 2)
        Vysvětlení:
        Celočíselné palindromy jsou 1, 2, 3. jeden z nich je sudý a dva z nich jsou liché.

    Příklad 2:

        Vstup: 12
        Výstup: (4, 6)
        Vysvětlení:
        Celočíselné palindromy jsou 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. čtyři z nich jsou sudé a 6 z nich je liché.

    Poznámka:
        1. 1 <= n <= 10^3
        2. vrácený tupl obsahuje počet sudých a lichých celočíselných palindromů.
    """


def count_nums(arr):
    """
    Napište funkci count_nums, která vezme pole celých čísel a vrátí
    počet prvků, který má součet číslic > 0.
    Pokud je číslo záporné, jeho první číslice se znaménkem bude záporná:
    např. -123 má číslice -1, 2 a 3 se znaménkem.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Přijme pole celých čísel a vrátí počet prvků, jejichž součet číslic je větší než 0
    Napište funkci count_nums.
    Pokud je číslo záporné, první číslice se znaménkem bude záporná:
    Příklad: -123 má číslice se znaménkem -1, 2, 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Máme pole 'arr' obsahující N celých čísel arr[1], arr[2], ..., arr[N].
    Čísla v poli jsou uspořádána náhodně. Úkolem je zjistit, zda je možné uspořádat
    pole v neklesajícím pořadí provedením následující operace na daném poli:
        Operaci posunu doprava lze provést libovolně mnohokrát.

    Operace posunu doprava znamená posunout všechny prvky pole doprava
    o jednu pozici. Poslední prvek pole se přesune na začátek pole, tj. na index 0.

    Pokud lze provést výše uvedenou operaci k získání uspořádaného pole, vraťte True, jinak vraťte False.
    Pokud je dané pole prázdné, vraťte True.

    Poznámka: Je zaručeno, že daný seznam má jedinečné prvky.

    Příklad:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Vysvětlení: Neklesající pořadí pro dané pole lze dosáhnout provedením operace posunu doprava 2krát.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Vysvětlení: Neklesající pořadí pro dané pole nelze dosáhnout žádným počtem posunů doprava.

    """

def move_one_ball(arr):
    """Máme pole 'arr' N celých čísel arr[1], arr[2], ..., arr[N].
    Čísla v poli jsou náhodně uspořádána. Vaším úkolem je určit, zda
    je možné získat pole seřazené v neklesajícím pořadí provedením
    následující operace na daném poli:
       Pravou směnu můžete provádět libovolný počet opakování.

    Jedna operace posunu doprava znamená posunutí všech prvků pole o jednu
    pozici doprava. Poslední prvek pole bude přesunut do
    počáteční pozice v poli, tj. 0. index.

    Pokud je možné získat setříděné pole provedením výše uvedené operace,
    vraťte True, jinak vraťte False.
    Pokud je dané pole prázdné, vrátí hodnotu True.

    Poznámka: U daného seznamu je zaručeno, že bude obsahovat jedinečné prvky.

    Například:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Vysvětlení: Provedením 2 operací posunu doprava lze dosáhnout neklesajícího pořadí v daném poli.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Vysvětlení: Není možné získat neklesající pořadí pro dané
              pole provedením libovolného počtu operací posunu doprava.

    """

def move_one_ball(arr):
    """Máme pole 'arr' z N celých čísel arr[1], arr[2], ..., arr[N].
    čísla v poli jsou náhodně uspořádaná. Vaším úkolem je určit, zda
    je možné získat pole seřazené v neklesajícím pořadí provedením
    následující operace na daném poli:
        Pravou směnu můžete provádět libovolný počet krát.

    Jedna operace posunu doprava znamená posunutí všech prvků pole o jeden
    pozici doprava. Poslední prvek pole bude přesunut do
    počáteční pozice v poli, tj. 0. index.

    Pokud je možné získat setříděné pole provedením výše uvedené operace
    pak vraťte True, jinak vraťte False.
    Pokud je dané pole prázdné, vrátí True.

    Poznámka: Dané pole obsahuje jedinečné prvky.

    Například:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Explanation: By performin 2 right shift operations, non-decreasing order can
                 be achieved for the given array.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Vysvětlení:Není možné získat neklesající pořadí pro dané
                pole provedením libovolného počtu operací posunu doprava.

    """


def exchange(lst1, lst2):
    """V tomto problému implementujete funkci, která bere dva seznamy čísel,
    a určuje, zda je možné provést výměnu prvků mezi nimi, aby se lst1 stal seznamem pouze sudých čísel.
    Počet vyměněných prvků mezi lst1 a lst2 není nijak omezen.
    Pokud je možné vyměňovat prvky mezi lst1 a lst2 tak, aby všechny prvky lst1 byly sudé,
    vrátí "YES".
    V opačném případě vraťte "NO".
    Například:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Předpokládá se, že vstupní seznamy nebudou prázdné.
    """

def exchange(lst1, lst2):
    """V tomto problému budete implementovat funkci, která vezme dva seznamy čísel,
    a určuje, zda je možné provést výměnu prvků
    mezi nimi, aby se lst1 stal seznamem pouze sudých čísel.
    Počet vyměněných prvků mezi lst1 a lst2 není nijak omezen.
    Pokud je možné vyměňovat prvky mezi lst1 a lst2 udělat
    aby všechny prvky lst1 byly sudé, vrátí "YES".
    V opačném případě vraťte "NO".
    Například:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Předpokládá se, že vstupní seznamy nebudou prázdné.
    """

def exchange(lst1, lst2):
    """V tomto problému obdržíme dva seznamy čísel,
    a implementujeme funkci pro určení, zda je možné
    vyměnit prvky mezi dvěma seznamy tak, aby lst1
    obsahoval pouze sudá čísla.
    Neexistuje žádné omezení na počet prvků, které lze
    vyměnit mezi lst1 a lst2.
    Pokud je možné vyměnit prvky mezi lst1 a lst2 tak,
    aby všechny prvky lst1 byly sudé, vrátí "YES".
    Pokud ne, vrátí "NO".
    Příklad:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Předpokládejme, že vstupní seznamy nejsou prázdné.
    """


def histogram(test):
    """Daný řetězec představující malá písmena oddělená mezerou vraťte slovník
    písmena s největším počtem opakování a obsahujícího odpovídající počet.
    Pokud má několik písmen stejný výskyt, vraťte je všechna.

    Příklad:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Řetězec malých písmen oddělených mezerou je dán, vrátí slovník znaků, které se vyskytují nejčastěji
    a zahrnuje počet těchto znaků.
    Pokud má více znaků stejný počet výskytů, vrátí všechny.

    Příklad:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Po zadání řetězce představujícího malá písmena oddělená mezerou vraťte slovník
    písmena s největším počtem opakování a obsahujícího odpovídající počet.
    Pokud má několik písmen stejný výskyt, vraťte je všechna.

    Příklad:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Úkol
    Když jsou dány dva řetězce s a c, je třeba odstranit všechny znaky v s, které se shodují se znaky v c,
    a poté zkontrolovat, zda je výsledný řetězec palindrom.
    Řetězec se nazývá palindrom, pokud se čte stejně zleva doprava i zprava doleva.
    Je třeba vrátit dvojici obsahující výsledný řetězec a hodnotu True/False pro kontrolu.
    Příklad
    Pokud s = "abcde", c = "ae", výsledek by měl být ('bcd',False).
    Pokud s = "abcdef", c = "b", výsledek by měl být ('acdef',False).
    Pokud s = "abcdedcba", c = "ab", výsledek by měl být ('cdedc',True).
    """

def reverse_delete(s,c):
    """Úkol
    Máme dva řetězce s a c, musíte odstranit všechny znaky v s, které se rovnají jakémukoli znaku v c
    pak zkontrolujte, zda je výsledný řetězec palindrom.
    Řetězec se nazývá palindrom, pokud se čte stejně dozadu jako dopředu.
    Měli byste vrátit n-tici obsahující výsledný řetězec a hodnotu True nebo False pro kontrolu.
    Příklad
    For s = "abcde", c = "ae", the result should be ('bcd',False)
    For s = "abcdef", c = "b"  the result should be ('acdef',False)
    For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
    """

def reverse_delete(s,c):
    """Úkol
    Dostali jsme dva řetězce s a c, musíte odstranit všechny znaky v s, které se rovnají libovolnému znaku v c
    Poté zkontrolujte, zda je výsledný řetězec palindrom.
    Řetězec se nazývá palindrom, pokud čte stejně dozadu jako dopředu.
    Měli byste vrátit řazenou kolekci členů obsahující výsledný řetězec a hodnotu True/False pro kontrolu.
    Příklad
    Pro s = "abcde", c = "ae" by měl být výsledek ('bcd',False)
    Pro s = "abcdef", c = "b" by měl být výsledek ('acdef',False)
    Pro s = "abcdedcba", c = "ab" by měl být výsledek ('cdedc',True)
    """


def odd_count(lst):
    """Když je poskytnut seznam řetězců, kde každý řetězec obsahuje pouze číslice.
    Každý prvek i výstupního seznamu musí být "počet lichých prvků v řetězci i vstupu".
    Zde musí být všechny i nahrazeny počtem lichých číslic v řetězci i vstupu.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """

def odd_count(lst):
    """Zadaný seznam řetězců, kde každý řetězec obsahuje pouze číslice, vrátí seznam.
    Každý prvek výstupu by měl být „počet lichých prvků v
    řetězci i. vstupu." kde všechna i by měla být nahrazena číslem
    lichých číslic v i'-tém řetězci vstupu.

    >>> odd_count(['1234567'])
    ["the number of odd elements 4n the str4ng 4 of the 4nput."]
    >>> odd_count(['3',"11111111"])
    ["the number of odd elements 1n the str1ng 1 of the 1nput.",
     "the number of odd elements 8n the str8ng 8 of the 8nput."]
    """


def minSubArraySum(nums):
    """
    Pro dané pole celých čísel nums, najděte nejmenší součet neprazdného podpole nums.
    Příklad
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Vzhledem k poli celých čísel nums najděte minimální součet libovolného neprázdného dílčího pole
    z nums.
    Příklad
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Dostanete obdélníkovou mřížku studní. Každý řádek představuje jednu studnu,
    a každá 1 v řadě představuje jednu jednotku vody.
    Každá studna má odpovídající kbelík, který lze použít k extrakci vody z ní,
    a všechny kbelíky mají stejnou kapacitu.
    Vaším úkolem je použít kbelíky k vyprázdnění studní.
    Výstup udává, kolikrát je třeba snížit kbelíky.

    Příklad 1:
        Vstup:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Výstup: 6

    Příklad 2:
        Vstup:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Výstup: 5

    Příklad 3:
        Vstup:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Výstup: 0

    Omezení:
        * všechny jamky mají stejnou délku
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Obdélníková mřížka studní je poskytnuta. Každý řádek představuje jednu studnu,
    a každý řádek má číslo 1 představující jednotku vody.
    Každá studna má kbelík, který může být použit k čerpání vody, a všechny kbelíky mají stejnou kapacitu.
    Úkolem je vyprázdnit studny pomocí kbelíku.
    Výstupem je počet spuštění kbelíku.

    Příklad 1:
        Vstup:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Výstup: 6

    Příklad 2:
        Vstup:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Výstup: 5

    Příklad 3:
        Vstup:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Výstup: 0

    Omezení:
        * Délka všech studní je stejná
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Dostanete obdélníkovou síť jamek. Každý řádek představuje jednu jamku,
    a každá 1 v řadě představuje jednu jednotku vody.
    Každá studna má odpovídající vědro, které lze použít k extrakci vody z ní,
    a všechny kbelík mají stejnou kapacitu.
    Vaším úkolem je pomocí kbelíků vyprázdnit studny.
    Vrátíte, kolikrát potřebujete snížit kbelíky.

    Příklad 1:
        Vstup:
             grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Výstup: 6

    Příklad 2:
        Vstup:
             grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Výstup: 5

    Příklad 3:
        Vstup:
             grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Výstup: 0

    Omezení:
        * all wells have the same length
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    V této Kata musíte seřadit pole nezáporných celých čísel podle
    počtu jedniček v jejich binární reprezentaci ve vzestupném pořadí.
    Pro podobný počet jedniček seřaďte podle desetinné hodnoty.

    Musí být implementován takto:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    V tomto Kata je třeba seřadit nezáporná celá čísla v poli vzestupně na základě počtu jedniček v binárním zobrazení.
    Pokud je počet jedniček stejný, seřaďte podle desetinné hodnoty.

    Mělo by být implementováno následovně:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """Když je dána řetězec s a přirozené číslo n, je třeba implementovat funkci,
    která vrátí seznam všech slov v řetězci s, která obsahují přesně n souhlásek.
    Tato slova jsou vrácena v pořadí, v jakém se objevují v řetězci s.
    Pokud je řetězec s prázdný, funkce musí vrátit prázdný seznam.
    Poznámka: Můžeme předpokládat, že vstupní řetězec obsahuje pouze písmena a mezery.
    Příklad:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """ Vzhledem k řetězci s a přirozenému číslu n jste dostali za úkol implementovat
    funkce, která vrací seznam všech slov z řetězců s, která obsahují přesně
    n souhlásek, v pořadí se tato slova objevují v řetězci s.
    Pokud je řetězec s prázdný, funkce by měla vrátit prázdný seznam.
    Poznámka: Můžete předpokládat, že vstupní řetězec obsahuje pouze písmena a mezery.
    Příklady:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Máte-li daný řetězec s a přirozené číslo n, máte za úkol je implementovat
    funkce, která vrací seznam všech slov z řetězců s, která obsahují přesně
    n souhlásek, v pořadí se tato slova objevují v řetězci s.
    Pokud je řetězec s prázdný, funkce by měla vrátit prázdný seznam.
    Poznámka: Můžete předpokládat, že vstupní řetězec obsahuje pouze písmena a mezery.
    Příklady:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Dostanete slovo. Vaším úkolem je najít nejbližší samohlásku, která stojí mezi dvěma souhláskami z pravé strany slova (rozlišují se malá a velká písmena).

    Samohlásky na začátku a na konci se nepočítají. Pokud jste nenašli žádnou samohlásku splňující výše uvedenou podmínku, vraťte prázdný řetězec.

    Můžete předpokládat, že daný řetězec obsahuje pouze anglická písmena.

    Příklad:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Je dáno slovo. Vaším úkolem je najít nejbližší samohlásku, která se nachází mezi
    dvěma souhláskami zprava ve slově (rozlišuje se velká a malá písmena).

    Samohlásky na začátku a na konci se nepočítají. Pokud není nalezena žádná samohláska,
    která splňuje výše uvedenou podmínku, vraťte prázdný řetězec.

    Můžete předpokládat, že daný řetězec obsahuje pouze anglické znaky.

    Příklad:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Je vám dáno slovo. Vaším úkolem je najít nejbližší samohlásku, která stojí mezi
    dvěma souhláskami z pravé strany slova. (rozlišují se malá a velká písmena).

    Samohlásky na začátku a na konci se nepočítají. Pokud jste nenašli žádnou samohlásku
    splňující výše uvedenou podmínku, vraťte prázdný řetězec.

    Můžete předpokládat, že daný řetězec obsahuje pouze anglická písmena.

    Příklad:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Je poskytnut seznam obsahující dva řetězce. Oba řetězce obsahují pouze otevírací závorky '(' nebo uzavírací závorky ')'.
    Vaším úkolem je zkontrolovat, zda je možné spojit oba řetězce v libovolném pořadí tak, aby vznikl dobrý řetězec.
    Řetězec S je považován za dobrý, pokud jsou všechny závorky v S vyvážené. Například: řetězec '(())()' je dobrý, ale řetězec '())' není dobrý.
    Pokud existuje způsob, jak vytvořit dobrý řetězec, vraťte 'Yes', jinak vraťte 'No'.

    Příklad:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Je dán seznam dvou řetězců, které se skládají pouze z otevřených závorek '(' a uzavřených závorek ')'.
    Vaším úkolem je zkontrolovat, zda je možné oba řetězce spojit v nějakém pořadí, aby výsledný řetězec byl vyvážený.
    Řetězec S je považován za vyvážený, pokud a pouze pokud všechny závorky v S jsou vyvážené.
    Například: řetězec '(())()' je vyvážený, zatímco řetězec '())' není.
    Vraťte 'Yes', pokud existuje způsob, jak vytvořit vyvážený řetězec, jinak vraťte 'No'.

    Příklady:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Dostanete seznam dvou řetězců, oba řetězce se skládají pouze ze závorek '(' nebo ')'.
    Vaším úkolem je zkontrolovat, zda je možné zřetězit dva řetězce
    nějakém pořadí, aby výsledný řetězec byl dobrý.
    Řetězec S je považován za dobrý tehdy a jen tehdy, jsou-li všechny závorky v S
    jsou správně závorkovány. Například: řetězec '(())()' je dobrý, zatímco řetězec
    „())“ není.
    Pokud existuje způsob, jak vytvořit dobrý řetězec, vraťte 'Yes', jinak vraťte 'No'.

    Příklady:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Pro dané pole celých čísel arr a kladné celé číslo k, vrátí seřazený seznam
    délky k vytvořený z maximálně k čísel v arr.

    Příklad 1:

        Vstup: arr = [-3, -4, 5], k = 3
        Výstup: [-4, -3, 5]

    Příklad 2:

        Vstup: arr = [4, -4, 4], k = 2
        Výstup: [4, 4]

    Příklad 3:

        Vstup: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Výstup: [2]

    Odkazy:
        1. Délka pole je v rozsahu [1, 1000].
        2. Prvky pole jsou v rozsahu [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Je-li dáno pole arr celých čísel a kladné celé číslo k, vrátí setříděný seznam
    délky k s maximálním k čísly v arr.

    Příklad 1:

      Vstup: arr = [-3, -4, 5], k = 3
      Výstup: [-4, -3, 5]

    Příklad 2:

      Vstup: arr = [4, -4, 4], k = 2
      Výstup: [4, 4]

    Příklad 3:

      Vstup: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
      Výstup: [2]

    Poznámka:
     1. Délka pole bude v rozsahu [1, 1000].
     2. Prvky v poli budou v rozsahu [-1000, 1000].
     3. 0 <= k <= len(arr)
    """


def solution(lst):
    """Za předpokladu, že seznam celých čísel není prázdný, vrátí součet všech lichých prvků, které jsou na párných pozicích.

    Příklady:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Když je zadán neprázdný seznam obsahující celá čísla, vraťte součet všech lichých prvků na sudých pozicích.

    Příklad
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """
    Zadaný seznam celých čísel není prázdný, vrátí součet všech lichých prvků, které se nacházejí na na indexech s sudým číslem.

    Příklady:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==> 0
    """


def add_elements(arr, k):
    """
    Vezměte neprázdné pole arr obsahující celá čísla a celé číslo k,
    vraťte součet prvků s maximálně dvěma číslicemi v prvních k prvcích pole arr.

    Příklad:

        Vstup: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Výstup: 24 # součet 21 + 3

    Omezení:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """
    """

def add_elements(arr, k):
    """
    Dané neprázdné pole celých čísel arr a celé číslo k, return
    součet prvků s nejvýše dvěma číslicemi z prvních k prvků arr.

    Příklad:

       Vstup: arr = [111,21,3,4000,5,6,7,8,9], k = 4
       Výstup: 24 # součet 21 + 3

    Omezení:
       1. 1 <= len(arr) <= 100
       2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Pokud je zadáno kladné celé číslo n, vrátí se seřazený seznam lichých čísel v Collatzově posloupnosti.

    Collatzova hypotéza je hypotéza v matematice o posloupnosti čísel definované následovně:
    Začněte s libovolným kladným celým číslem n. Poté je každý člen odvozen z předchozího členu takto:
    Pokud je předchozí člen sudý, následující člen je polovina předchozího členu.
    Pokud je předchozí člen lichý, následující člen je trojnásobek předchozího členu plus 1.
    Tato hypotéza tvrdí, že bez ohledu na hodnotu n posloupnost vždy dosáhne 1.

    Odkazy:
        1. Collatz(1) je [1].
        2. Vrácený seznam je seřazený vzestupně.

    Příklad:
    get_odd_collatz(5) vrátí [1, 5]. # Collatzova posloupnost pro 5 je [5, 16, 8, 4, 2, 1], a lichá čísla jsou pouze 1 a 5.
    """

def get_odd_collatz(n):
    """
    Zadáno kladné celé číslo n, vrátí seřazený seznam, který obsahuje lichá čísla v Collatzově posloupnosti.

    Collatzova domněnka je domněnka v matematice, která se týká sekvence definované
    následovně: začněte libovolným kladným celým číslem n. Potom je každý následující člen získán
    z předchozího termínu takto: je-li předchozí termín sudý, další termín je polovina předchozího čísla.
    Pokud je předchozí termín lichý, další termín je 3 krát předchozí člen plus 1. Předpokládá se, že bez ohledu na hodnotu n posloupnost vždy dosáhne 1.

    Poznámka:
    1. Collatz(1) je [1].
    2. Vrácený seznam je seřazený vzestupně.

    Například:
    get_odd_collatz(5) vrací [1, 5] # Collatzova sekvence pro 5 je [5, 16, 8, 4, 2, 1], takže lichá čísla jsou pouze 1 a 5.
    """


def valid_date(date):
    """Napište funkci pro kontrolu zadaného řetězce data a vraťte True, pokud je datum platné, jinak vraťte False.
    Aby bylo datum platné, musí být splněna všechna následující pravidla:
    1. Řetězec data nesmí být prázdný.
    2. Pro měsíce 1,3,5,7,8,10,12 nesmí být počet dní menší než 1 nebo větší než 31. A pro měsíce 4,6,9,11 nesmí být počet dní menší než 1 nebo větší než 30. A pro měsíc 2 nesmí být počet dní menší než 1 nebo větší než 29.
    3. Měsíc nesmí být menší než 1 nebo větší než 12.
    4. Datum musí mít následující formát: mm-dd-yyyy

    Příklad:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def valid_date(date):
    """Musíte napsat funkci, která ověří daný řetězec data a
    vrátí True, pokud je datum platné, jinak False.
    Datum je platné, pokud jsou splněna všechna následující pravidla:
    1. Řetězec data není prázdný.
    2. Počet dní není menší než 1 nebo vyšší než 31 dní pro měsíce 1,3,5,7,8,10,12. A počet dní není menší než 1 nebo vyšší než 30 dní pro měsíce 4,6,9,11. A počet dní není menší než 1 nebo vyšší než 29 za měsíc 2.
    3. Měsíce by neměly být menší než 1 nebo vyšší než 12.
    4. Datum by mělo být ve formátu: mm-dd-rrrr

    například:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """

def platné_datum(datum):
    """Musíte napsat funkci, která ověří daný řetězec data a
    vrátí True, pokud je datum platné, jinak False.
    Datum je platné, pokud jsou splněna všechna následující pravidla:
    1. Řetězec data není prázdný.
    2. Počet dní není menší než 1 nebo vyšší než 31 dní pro měsíce 1,3,5,7,8,10,12. A počet dní není menší než 1 nebo vyšší než 30 dní pro měsíce 4,6,9,11. A počet dní není menší než 1 nebo vyšší než 29 za měsíc 2.
    3. Měsíce by neměly být menší než 1 nebo vyšší než 12.
    4. Datum by mělo být ve formátu: mm-dd-rrrr

    například:
    valid_date('03-11-2000') => True

    valid_date('15-01-2012') => False

    valid_date('04-0-2040') => False

    valid_date('06-04-2020') => True

    valid_date('06/04/2020') => False
    """


def split_words(txt):
    '''
    Rozdělí slova v daném řetězci pomocí mezer a vrátí je jako seznam.
    Pokud nejsou mezery, rozdělí pomocí čárky ',' a pokud také nejsou čárky,
    vrátí počet malých písmen na lichých pozicích v abecedě.
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Příklad
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Zadaný řetězec slov vraťte seznam slov rozdělených na mezery, pokud v textu žádné mezery nejsou,
    měl by se rozdělit na čárky ',' pokud žádné čárky neexistují, měli byste vrátit počet malých písmen s lichým pořadím v
    abecedě, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Příklady:
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Vzhledem k řetězci slov vraťte seznam slov rozdělených na mezery, pokud v textu nejsou mezery
    měl by se text rozdělit na čárky ',' pokud žádné čárky neexistují, měli byste vrátit počet malých písmen s lichým pořadím
    v abecedě, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Příklady
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Pro zadaný seznam čísel vraťte, zda jsou seřazeny ve vzestupném pořadí.
    Pokud seznam obsahuje více než jednu kopii stejného čísla, vraťte False.
    Předpokládejte, že nejsou záporná čísla a pouze celá čísla.

    Příklady:
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Na základě seznamu čísel zjistěte, zda jsou seřazena ve vzestupném pořadí. Pokud seznam obsahuje více než jeden duplicitní výskyt stejného čísla, vraťte hodnotu False. Nepředpokládejte žádná záporná čísla, pouze celá čísla.

    Příklady
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Když je zadán seznam čísel, vrátí, zda je seznam seřazen v rostoucím pořadí.
    Pokud se některé číslo v seznamu vyskytne více než jednou, vrátí False.
    Předpokládejme, že neexistují žádná záporná čísla a pouze celá čísla.

    Příklad:
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Dva zadané intervaly,
    každý interval je dvojice celých čísel. Například, interval = (start, end) = (1, 2).
    Zadané intervaly jsou uzavřené, interval (start, end) zahrnuje
    jak start, tak end.
    Pro každý zadaný interval předpokládáme, že začátek je menší nebo roven konci.
    Úkolem je zjistit, zda délka průniku dvou intervalů je prvočíslo.
    Například, průnik intervalů (1, 3), (2, 4) je (2, 3) a
    jeho délka je 1, což není prvočíslo.
    Pokud je délka průniku prvočíslo, vrátí "YES",
    jinak vrátí "NO".
    Pokud se dva intervaly nepřekrývají, vrátí "NO".

    [Příklad vstupu/výstupu]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Jsou vám dány dva intervaly,
    kde každý interval je dvojicí celých čísel. Například interval = (začátek, konec) = (1, 2).
    Uvedené intervaly jsou uzavřené, což znamená, že interval (začátek, konec)
    zahrnuje začátek i konec.
    Pro každý daný interval se předpokládá, že jeho začátek je menší nebo roven jeho konci.
    Vaším úkolem je určit, zda délka průsečíku těchto dvou
    intervaly je prvočíslo.
    Příklad, průsečík intervalů (1, 3), (2, 4) je (2, 3)
    jehož délka je 1, což není prvočíslo.
    Pokud je délka křižovatky prvočíslo, vraťte "ANO",
    jinak vraťte "NE".
    Pokud se tyto dva intervaly neprotínají, vraťte "NE".

    [vstup/výstup] vzorky:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def průnik(interval1, interval2):
    ""Jsou vám dány dva intervaly,
    kde každý interval je dvojicí celých čísel. Například interval = (začátek, konec) = (1, 2).
    Dané intervaly jsou uzavřené, což znamená, že interval (začátek, konec)
    Zahrnuje začátek i konec.
    Pro každý daný interval se předpokládá, že jeho začátek je menší nebo roven jeho konci.
    Vaším úkolem je zjistit, zda je délka průsečíku těchto dvou
    intervaly je prvočíslo.
    Příklad: průsečík intervalů (1, 3), (2, 4) je (2, 3)
    jehož délka je 1, což není prvočíslo.
    Pokud je délka průsečíku prvočíslo, vrátí "YES",
    v opačném případě vrátí hodnotu "NO".
    Pokud se tyto dva intervaly neprotínají, vrátí hodnotu "NO".

    [vstup/výstup] vzorky:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Pro dané pole celých čísel arr, je třeba vrátit součet velikostí celých čísel
    vynásobený součinem znamének jednotlivých čísel v poli. Znaménko je reprezentováno
    hodnotami 1, -1 nebo 0.
    Poznámka: V případě prázdného pole vrátit None.

    Příklad:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Je vám zadáno pole arr celých čísel a musíte vrátit
    součet velikostí celých čísel vynásobený součinem všech znamének
    každého čísla v poli, které je reprezentováno 1, -1 nebo 0.
    Poznámka: return None pro prázdný arr.

    Příklad:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Dostanete pole arr celých čísel a musíte se vrátit
    součet velikostí celých čísel vynásobený součinem všech znamének
    každého čísla v poli reprezentovaného 1, -1 nebo 0.
    Poznámka: return None pro prázdný arr.

    Příklad:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Je-li dána mřížka s N řádky a N sloupci (N >= 2) a kladným celým číslem k,
    každá buňka mřížky obsahuje určitou hodnotu. Každé celé číslo z rozsahu [1, N * N]
    se v mřížce objeví přesně jednou.

    Vaším úkolem je najít minimální cestu délky k v mřížce. Můžete začít
    z libovolné buňky, a v každém kroku se můžete přesunout do kterékoli sousední buňky.
    Jinými slovy, můžete přejít do buněk, které sdílejí společnou hranu s vaší aktuální
    buňkou.
    Upozorňujeme, že cesta délky k znamená návštěvu přesně k buněk (nemusí být různé).
    NEMŮŽETE opustit mřížku.

    Cesta A (délky k) je považována za menší než cesta B (délky k), pokud
    po vytvoření uspořádaných seznamů hodnot v buňkách, kterými A a B procházejí
    (nazvěme je lst_A a lst_B), je lst_A lexikograficky menší než lst_B.
    Jinými slovy, existuje celočíselný index i (1 <= i <= k) takový, že lst_A[i] < lst_B[i],
    a pro libovolné j (1 <= j < i) platí lst_A[j] = lst_B[j].

    Je zaručeno, že odpověď je jednoznačná.
    Funkce vrátí seřazený seznam hodnot v buňkách, kterými prochází minimální cesta.

    Příklady:

        Vstup: mřížka = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Výstup: [1, 2, 1]

        Vstup: mřížka = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Výstup: [1]
    """

def minPath(grid, k):
    """
    Je-li dána mřížka s N řádky a N sloupci (N >= 2) a kladným celým číslem k,
    každá buňka mřížky obsahuje hodnotu. Každé celé číslo v rozsahu [1, N * N]
    včetně se na buňkách mřížky objeví přesně jednou.

    Musíte najít minimální cestu délky k v mřížce. Můžete začít
    z libovolné buňky a v každém kroku se můžete přesunout do jakékoli sousední buňky,
    jinými slovy, můžete se přesunout do buněk, které sdílejí hranu s vaší aktuální buňkou.
    Upozorňujeme, že cesta o délce k znamená návštěvu přesně k buněk (ne
    nutně odlišné).
    Nemůžete opustit mřížku.
    Dráha A (o délce k) je menší než dráha B (o délce k), pokud
    po vytvoření uspořádaných seznamů hodnot v buňkách, kterými A a B procházejí,
    lst_A je lexikograficky menší než lst_B, jinými slovy, existuje celočíselný index i (1 <= i <= k)
    takový, že lst_A[i] < lst_B[i] a pro libovolné j (1 <= j < i) máme
    lst_A[j] = lst_B[j].
    Je zaručeno, že odpověď je jedinečná.
    Vrátí seřazený seznam hodnot v buňkách, kterými prochází minimální cesta.

    Příklady:

      Vstup: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
      Výstup: [1, 2, 1]

      Vstup: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
      Výstup: [1]
    """

def minPath(grid, k):
    """
    Je dán grid s N řádky a N sloupci (N >= 2) a kladné celé číslo k,
    každá buňka v gridu obsahuje hodnotu. Všechny celé čísla v rozsahu [1, N * N]
    se v gridu objeví přesně jednou.

    Je třeba najít minimální cestu délky k v gridu. Můžete začít v libovolné buňce a
    v každém kroku se můžete přesunout do sousední buňky. To znamená, že se můžete
    přesunout do buňky, která sdílí hranu s aktuální buňkou.
    Cesta délky k znamená navštívit přesně k buňek (nemusí být nutně různé).
    Nesmíte opustit grid.
    Cesta A délky k je považována za menší než cesta B, pokud
    vytvoříme seřazený seznam hodnot buňek, kterými A a B procházejí (nazvěme je lst_A a lst_B),
    lst_A je lexikograficky menší než lst_B. To znamená, že existuje index i (1 <= i <= k),
    pro který platí lst_A[i] < lst_B[i], a pro libovolné j (1 <= j < i) platí lst_A[j] = lst_B[j].
    Je zaručeno, že odpověď je jedinečná.
    Vrátí se seřazený seznam hodnot buňek, kterými minimální cesta prochází.

    Příklad:

        Vstup: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Výstup: [1, 2, 1]

        Vstup: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Výstup: [1]
    """


def tri(n):
    """Každý zná Fibonacciho posloupnost a ta byla zkoumána matematiky po mnoho staletí.
    Nicméně, méně známá je Tribonacciho posloupnost.
    Tribonacciho posloupnost je definována následujícím rekurentním vzorcem:
    tri(1) = 3
    tri(n) = 1 + n / 2, když n je sudé číslo.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), když n je liché číslo.
    Příklad:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Když je zadáno nezáporné celé číslo n, je třeba vrátit prvních n + 1 čísel Tribonacciho posloupnosti.
    Příklad:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Každý zná Fibonacciho posloupnost, která byla hluboce studována matematiky v
    posledních pár století. Co však lidé nevědí, je Tribonacciho posloupnost.
    Tribonacciho posloupnost je definována opakováním:
    tri(1) = 3
    tri(n) = 1 + n / 2, pokud je n sudé.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), pokud je n liché.
    Příklad:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Dostanete nezáporné celé číslo n a musíte vrátit seznam
    prvních n + 1 čísel Tribonacciho posloupnosti.
    Příklady:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    ""Každý zná Fibonacciho posloupnost, byla hluboce studována matematiky v
    posledních pár století. Co však lidé neznají, je Tribonacciho posloupnost.
    Tribonacciho posloupnost je definována opakováním:
    tri(1) = 3
    tri(n) = 1 + n / 2, pokud n je sudé.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), pokud n je liché.
    Například:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Je vám zadáno nezáporné celé číslo n, musíte vrátit seznam
    prvních n + 1 čísel Tribonacciho posloupnosti.
    Příklady:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Když je zadáno kladné celé číslo n, vrátí součin lichých číslic.
    Pokud jsou všechny číslice sudé, vrátí 0.
    Příklad:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Vzhledem k kladnému celému číslu n vraťte součin lichých číslic.
    Vraťte 0, pokud jsou všechny číslice sudé.
    Například:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(řetězec):
    '''
    Vytvořte funkci, která jako vstup bere řetězec, který obsahuje pouze hranaté závorky.
    Funkce by měla vrátit hodnotu True tehdy a pouze tehdy, pokud existuje platná podsekvence závorek
    kde je vnořena alespoň jedna hranatá závorka v podsekvenci.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Vytvořte funkci, která vezme jako vstup řetězec, který obsahuje pouze hranaté závorky.
    Funkce by měla vrátit True tehdy a jen tehdy, když existuje platná podřetězcová posloupnost závorek,
    kde je alespoň jedna závorka vnořená v podřetězci.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''

def is_nested(string):
    '''
    Vytvořte funkci, která přijímá řetězec obsahující pouze hranaté závorky.
    Tato funkce by měla vrátit True, pouze pokud existuje platná podřetězec závorek,
    a tento podřetězec musí obsahovat alespoň jednu vnořenou závorku.

    is_nested('[[]]') ➞ True
    is_nested('[]]]]]]][[[[[]') ➞ False
    is_nested('[][]') ➞ False
    is_nested('[]') ➞ False
    is_nested('[[][]]') ➞ True
    is_nested('[[]][[') ➞ True
    '''


def sum_squares(lst):
    """Je dán seznam čísel.
    Je třeba vrátit součet čísel po zaokrouhlení každého prvku
    v seznamu na nejbližší větší celé číslo.
    Příklad:
    lst = [1,2,3] pak výstup musí být 14.
    lst = [1,4,9] pak výstup musí být 98.
    lst = [1,3,5,7] pak výstup musí být 84.
    lst = [1.4,4.2,0] pak výstup musí být 29.
    lst = [-2.4,1,1] pak výstup musí být 6.

    """

def sum_squares(lst):
    ""Dostanete seznam čísel.
    Musíte vrátit součet čtvercových čísel v daném seznamu,
    zaokrouhlete každý prvek v seznamu nejprve na horní int(Ceiling).
    Příklady:
    Pro lst = [1,2,3] by měl být výstup 14
    Pro lst = [1,4,9] by měl být výstup 98
    Pro lst = [1,3,5,7] by měl být výstup 84
    Pro lst = [1.4,4.2,0] by měl být výstup 29
    Pro lst = [-2.4,1,1] by výstup měl být 6

    """

def sum_squares(lst):
    """Dostanete seznam čísel.
    Musíte vrátit součet čtverců čísel v daném seznamu,
    zaokrouhlete nejprve každý prvek v seznamu na horní celé číslo (Strop).
    Příklady:
    For lst = [1,2,3] the output should be 14
    For lst = [1,4,9] the output should be 98
    For lst = [1,3,5,7] the output should be 84
    For lst = [1.4,4.2,0] the output should be 29
    For lst = [-2.4,1,1] the output should be 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Vytvořte funkci, která vrátí True, pokud je poslední znak daného řetězce písmeno
    a není součástí slova.
    Jinak vrátí False.
    Poznámka: "slovo" je skupina znaků oddělená mezerou.

    Příklad:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Vytvořte funkci, která vrací hodnotu True, pokud je poslední znak
    daného řetězce je písmeno a není součástí slova
    část slova a v opačném případě False.
    Poznámka: "slovo" je skupina znaků oddělených mezerou.

    Příklady:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Vytvořte funkci, která vrátí True, pokud je poslední znak
    daného řetězce je abecední znak a není
    část slova a jinak False.
    Poznámka: "slovo" je skupina znaků oddělených mezerou.

    Příklady:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Vytvořte funkci, která vrátí největší index prvku, který není větší nebo rovný prvku přímo před ním
    v daném poli. Pokud takový prvek neexistuje, vraťte -1.
    Dané pole neobsahuje duplicitní hodnoty.

    Příklad:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Vytvořte funkci, která vrátí největší index prvku, který
    není větší nebo rovno prvku bezprostředně předcházejícímu. Li
    žádný takový prvek neexistuje, pak vraťte -1. Dané pole nebude obsahovat
    duplicitní hodnoty.

    Příklady:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Vytvořte funkci, která vrací největší index prvku, který
    není větší ani roven elementu, který mu bezprostředně předchází. Když
    žádný takový prvek neexistuje, pak return -1. Dané pole nebude obsahovat
    duplicitní hodnoty.

    Příklady:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Vytvořte funkci, která vrací dvojici (a, b), kde 'a' je
    největší ze záporných celých čísel a 'b' je nejmenší
    z kladných celých čísel v seznamu.
    Pokud nejsou v seznamu žádná záporná nebo kladná celá čísla, vraťte None.

    Příklady:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Vytvořte funkci, která vrátí největší záporné číslo 'a' a nejmenší kladné číslo 'b'
    ze seznamu jako dvojici (a, b).
    Pokud neexistuje žádné záporné nebo kladné číslo, vraťte None.

    Příklad:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Vytvořte funkci, která vrátí n-tici (a, b), kde je 'a'
    největší ze záporných celých čísel a 'b' je nejmenší
    kladných celých čísel v seznamu.
    Pokud neexistují žádná záporná nebo kladná celá čísla, vraťte je jako Žádná.

    Příklady:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Vytvořte funkci, která přijme celá čísla, plovoucí čísla nebo řetězce reprezentující
    reálná čísla a vrátí větší proměnnou v daném typu proměnné.
    Vrátí None, pokud jsou hodnoty stejné.
    Poznámka: Pokud je reálné číslo reprezentováno jako řetězec, plovoucí desetinná čárka může být . nebo ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Vytvořte funkci, která přijme celá čísla, plovoucí čísla nebo řetězce
    reálná čísla a vrátí větší proměnnou v daném typu proměnné.
    Pokud jsou hodnoty stejné, vrátí None.
    Poznámka: Pokud je reálné číslo reprezentováno jako řetězec, desetinná čárka může být . nebo ,

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """

def compare_one(a, b):
    """
    Vytvořte funkci, která přijímá celá čísla, desetinná čísla nebo řetězce reprezentující reálná čísla,
    a vytvořte funkci, která vrátí větší proměnnou v daném typu proměnné.
    Pokud jsou hodnoty stejné, vraťte None.
    Poznámka: Když je reálné číslo reprezentováno jako řetězec, desetinná čárka může být . nebo ,.

    compare_one(1, 2.5) ➞ 2.5
    compare_one(1, "2,3") ➞ "2,3"
    compare_one("5,1", "6") ➞ "6"
    compare_one("1", 1) ➞ None
    """


def is_equal_to_sum_even(n):
    """Vyhodnotí, zda dané číslo n může být přesně vyjádřeno jako součet 4 kladných sudých čísel
    Příklad
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
     """Vyhodnoťte, zda dané číslo n lze zapsat jako součet právě 4 kladných sudých čísel
    Příklad
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Vyhodnoťte, zda lze dané číslo n zapsat jako součet právě 4 kladných sudých čísel
    Příklad
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Brazilský faktoriál je definován jako:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    kde  n > 0

    Například:
    >>> special_factorial(4)
    288

    Funkce obdrží celé číslo jako vstup a vrátí speciální
    faktoriál tohoto čísla.
    """

def special_factorial(n):
    """Brazilský faktoriál je definován následovně:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    kde n > 0

    Příklad:
    >>> special_factorial(4)
    288

    Tato funkce přijímá celé číslo jako vstup a musí vrátit speciální faktoriál tohoto celého čísla.
    """

def special_factorial(n):
     """Brazilský faktoriál je definován jako:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    kde n > 0

    Například:
    >>> special_factorial(4)
    288

    Funkce obdrží jako vstup celé číslo a měla by vrátit speciální
    faktoriál tohoto celého čísla.
    """


def fix_spaces(text):
    """
    Zadaný textový řetězec nahraďte všechny mezery v něm podtržítky,
    a pokud má řetězec více než 2 po sobě jdoucí mezery,
    nahraďte všechny po sobě jdoucí mezery znakem -

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """

def fix_spaces(text):
    """
    Nahraďte všechny mezery v poskytnutém textovém řetězci podtržítkem,
    a pokud jsou v řetězci 2 nebo více po sobě jdoucích mezer,
    nahraďte všechny po sobě jdoucí mezery pomlčkou.

    fix_spaces("Example") == "Example"
    fix_spaces("Example 1") == "Example_1"
    fix_spaces(" Example 2") == "_Example_2"
    fix_spaces(" Example   3") == "_Example-3"
    """


def file_name_check(file_name):
    """Přijme název souboru jako řetězec a vytvoří funkci, která vrátí 'Yes', pokud je název souboru platný, jinak vrátí 'No'.
    Název souboru je považován za platný, pokud jsou splněny všechny následující podmínky:
    - Název souboru nesmí obsahovat více než tři číslice ('0'-'9').
    - Název souboru musí obsahovat přesně jednu tečku '.'.
    - Podřetězec před tečkou nesmí být prázdný a musí začínat latinským písmenem ('a'-'z' a 'A'-'Z').
    - Podřetězec za tečkou musí být jednou z následujících hodnot: ['txt', 'exe', 'dll']
    Příklad:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (Název musí začínat latinským písmenem)
    """

def file_name_check(file_name):
    """Vytvořte funkci, která vezme řetězec představující název souboru a vrátí
    'Yes', pokud je název souboru platný, a v opačném případě vrátí 'No'.
    Název souboru se považuje za platný tehdy a pouze tehdy, pokud jsou splněny všechny následující podmínky
    jsou splněny:
    - V názvu souboru by neměly být více než tři číslice ('0'-'9').
    - Název souboru obsahuje právě jednu tečku '.'
    - Podřetězec před tečkou by neměl být prázdný a začíná písmenem z
    latinským alfabetem ("a"-"z" a "A"–"Z").
    - Podřetězec za tečkou by měl být jeden z těchto: ['txt', 'exe', 'dll']
    Příklady:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (jméno by mělo začínat latinským písmenem latinským písmenem)
    """

def file_name_check(file_name):
    """Vytvořte funkci, která vezme řetězec představující název souboru a vrátí se
    „Ano“, pokud je název souboru platný, a jinak vrátí „Ne“.
    Název souboru je považován za platný tehdy a pouze za splnění následujících podmínek
    jsou splněny:
    - V názvu souboru by nemělo být více než tři číslice ('0'-'9').
    - Název souboru obsahuje přesně jednu tečku '.'
    - Podřetězec před tečkou by neměl být prázdný a začíná písmenem od
    latinská abeceda ('a'-'z' a 'A'-'Z').
    – Podřetězec za tečkou by měl být jeden z těchto: ['txt', 'exe', 'dll']
    Příklady:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (název by měl začínat písmenem latinské abecedy)
    """


def sum_squares(lst):
    """
    Tato funkce převezme seznam celých čísel. U všech položek v seznamu funkce umocní celočíselnou položku na druhou, pokud je její index násobkem 3,
    a bude umocňovat celočíselnou položku na třetí, pokud je její index násobkem 4 a ne násobkem 3. Funkce nebude měnit položky v seznamu, jejichž indexy
    nejsou násobkem 3 nebo 4. Funkce poté vrátí součet všech položek.

    Příklady:
    Pro lst = [1, 2, 3] výstup bude 6
    Pro lst = [] výstup bude 0
    Pro lst = [-1, -5, 2, -1, -5] výstup bude -126
    """

def sum_squares(lst):
    """"
    TTato funkce přijímá seznam celých čísel jako vstup. Pro všechny položky v seznamu funkce umocní položku na druhou, pokud je její index násobkem 3, a umocní ji na třetí, pokud je její index násobkem 4, ale není násobkem 3. Položky, jejichž index není násobkem 3 ani 4, zůstanou nezměněny. Poté funkce vrátí součet všech položek.

    Příklady:
    Pro lst = [1,2,3] by měl být výstup 6
    Pro lst = [] by výstup měl být 0
    Pro lst = [-1,-5,2,-1,-5] by měl být výstup -126
    """

def sum_squares(lst):
    """
    Tato funkce přijímá seznam celých čísel jako vstup. U všech položek v seznamu musí funkce čtvercovat celočíselnou položku, pokud je její index násobek 3,
    a bude celočíselnou položku kostkou, pokud je její index násobek 4 a ne násobek 3. Položky, které nejsou násobkem 3 nebo 4, se nezmění.
    Poté funkce vrátí součet všech položek.

    Příklad:
    lst = [1,2,3] pak výstup musí být 6.
    lst = [] pak výstup musí být 0.
    lst = [-1,-5,2,-1,-5] pak výstup musí být -126.
    """


def words_in_sentence(sentence):
    """
    Je dána věta reprezentovaná jako řetězec.
    Tato věta obsahuje několik slov oddělených mezerami,
    a je třeba vrátit řetězec obsahující slova, jejichž délka je prvočíslo,
    z původní věty. Pořadí slov v novém řetězci musí odpovídat původní větě.

    Příklad 1:
        Vstup: sentence = "This is a test"
        Výstup: "is"

    Příklad 2:
        Vstup: sentence = "lets go for swimming"
        Výstup: "go for"

    Omezení:
        * 1 <= len(sentence) <= 100
        * sentence obsahuje pouze písmena
    """

def words_in_sentence(sentence):
    """
    Dostanete řetězec představující větu,
    věta obsahuje některá slova oddělená mezerou,
    a musíte vrátit řetězec, který obsahuje slova z původní věty,
    jehož délky jsou prvočísla,
    pořadí slov v novém řetězci by mělo být stejné jako v původním.

    Příklad 1:
        Vstup: sentence = "This is a test"
        Výstup: "is"

    Příklad 2:
        Vstup: sentence = "lets go for swimming"
        Výstup: "go for"

    Omezení:
         * 1 <= len(sentence) <= 100
         * sentence obsahuje pouze písmena
     """

def words_in_sentence(sentence):
    """
    Dostanete řetězec představující větu,
    věta obsahuje některá slova oddělená mezerou,
    a musíte vrátit řetězec, který obsahuje slova z původní věty,
    jehož délky jsou prvočísla,
    pořadí slov v novém řetězci by mělo být stejné jako v původním řetězci.

    Příklad 1:
        Vstup: sentence = "This is a test"
        Výstup: "is"

    Příklad 2:
       Vstup: sentence = "lets go for swimming"
        Výstup: "go for"

    Omezení:
        * 1 <= len(sentence) <= 100
        * věta obsahuje pouze písmena
    """


def simplify(x, n):
    """Vaším úkolem je implementovat funkci pro zjednodušení výrazu x * n.
    Funkce vrátí True, pokud je x * n hodnoceno jako celé číslo, jinak vrátí False.
    x a n jsou oba řetězcové reprezentace zlomků ve formátu:
    <čitatel>/<jmenovatel>, kde čitatel a jmenovatel jsou kladná celá čísla.

    Můžete předpokládat, že x a n jsou platné zlomky a jmenovatel není 0.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Vaším úkolem je implementovat funkci, která zjednoduší výraz x * n. Funkce vrací True, pokud je x * n celé číslo, a False jinak. Obě hodnoty x a n jsou
    řetězcové reprezentace zlomků a mají následující formát:
    <numerator>/<denominator> kde čitatel i jmenovatel jsou kladná celá čísla.

    Můžete předpokládat, že x a n jsou platné zlomky a nemají nulu jako jmenovatele.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """

def simplify(x, n):
    """Vaším úkolem je implementovat funkci, která výraz zjednoduší
    x * n. Funkce vrátí True, pokud je x * n vyhodnoceno jako celé číslo a False
    jinak. Oba x a n jsou řetězcové reprezentace zlomku a mají následující formát:
    <čitatel>/<jmenovatel> kde čitatel i jmenovatel jsou kladná celá čísla.

    Můžete předpokládat, že x an jsou platné zlomky a nemají ve jmenovateli nulu.

    simplify("1/5", "5/1") = True
    simplify("1/6", "2/1") = False
    simplify("7/10", "10/2") = False
    """


def order_by_points(nums):
    """
    Napište funkci, která seřadí daný seznam celých čísel
    ve vzestupném pořadí podle součtu jejich číslic.
    Poznámka: pokud existuje několik položek s podobným součtem jejich číslic,
    seřadit je na základě jejich indexu v původním seznamu.

    Například:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Napište funkci, která seřadí daný seznam celých čísel vzestupně podle součtu číslic každého čísla.
    Poznámka: Pokud má více položek stejný součet číslic, seřaďte podle indexu v původním seznamu.

    Příklad:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Napište funkci, která seřadí daný seznam celých čísel
    ve vzestupném pořadí podle součtu jejich číslic.
    Poznámka: pokud existuje více položek s podobným součtem jejich číslic,
    Seřaďte je podle jejich indexu v původním seznamu.

    Například:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Napište funkci, která vezme pole čísel jako vstup a vrátí
    počet prvků v poli, které jsou větší než 10 a obojí
    první a poslední číslice čísla jsou liché (1, 3, 5, 7, 9).
    Například:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(čísla):
    """Napište funkci, která vezme pole čísel jako vstup a vrátí se
    počet prvků v poli, které jsou větší než 10 a oba
    První a poslední číslice čísla jsou liché (1, 3, 5, 7, 9).
    Například:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Přijměte pole čísel jako vstup a napište funkci, která vrátí počet prvků v poli,
    které jsou větší než 10 a obě číslice, první i poslední, jsou liché (1, 3, 5, 7, 9).
    Příklad:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Je vám dáno kladné celé číslo n. Musíte vytvořit celočíselné pole a o délce n.
        Pro každé i (1 ≤ i ≤ n) je hodnota a[i] = i * i - i + 1.
        Vrátí počet trojic (a[i], a[j], a[k]) čísla a, kde i < j < k,
    a a[i] + a[j] + a[k] je násobkem 3.

    Příklad:
        Vstup: n = 5
        Výstup: 1
        Vysvětlení:
        a = [1, 3, 7, 13, 21]
        Jediná platná trojice je (1, 7, 13).
    """

def get_max_triples(n):
    """
    Pro dané kladné celé číslo n. Je třeba vytvořit pole celých čísel a délky n.
        Pro každé i (1 ≤ i ≤ n), hodnota a[i] je i * i - i + 1.
        Vrátí počet trojic (a[i], a[j], a[k]) v a s i < j < k.
        A a[i] + a[j] + a[k] je násobkem 3.

    Příklad:
        Vstup: n = 5
        Výstup: 1
        Vysvětlení:
        a = [1, 3, 7, 13, 21]
        Jediná platná trojice je (1, 7, 13).
    """

def get_max_triples(n):
    """
    Dostanete kladné celé číslo n. Musíte vytvořit celočíselné pole a délky n.
        Pro každé i (1 ≤ i ≤ n) je hodnota a[i] = i * i - i + 1.
        Vraťte počet trojic (a[i], a[j], a[k]) z a, kde i < j < k,
    a a[i] + a[j] + a[k] je násobek 3.

    Příklad:
        Vstup: n = 5
        Výstup: 1
        Vysvětlení:
        a = [1, 3, 7, 13, 21]
        Jediná platná trojka je (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Sluneční soustava má osm planet: nejblíže ke Slunci je Merkur,
    následuje Venuše, Země, Mars, Jupiter, Saturn, Uran, Neptun.
    Napište funkci, která přijímá názvy dvou planet jako řetězce: planet1 a planet2.
    Funkce musí vrátit n-tici obsahující všechny planety mezi oběžnými drahami planet1 a planet2,
    seřazené podle pořadí nejblíže ke Slunci.
    Pokud planet1 nebo planet2 není platný název planety, vraťte prázdnou n-tici.
    Příklad
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    V naší sluneční soustavě je osm planet: ta nejblíže Slunci
    je Merkur, další je Venuše, pak Země, Mars, Jupiter, Saturn,
    Uran, Neptun.
    Napište funkci, která vezme dvě jména planet jako řetězce planet1 a planet2.
    Funkce by měla vrátit n-tici obsahující všechny planety, jejichž oběžné dráhy jsou
    nachází se mezi oběžnou dráhou planety1 a oběžnou dráhou planety2, seřazeno podle
    blízkost slunce.
    Funkce by měla vrátit prázdnou n-tici, pokud planeta1 nebo planeta2
    nejsou správná jména planet.
    Příklady
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planeta1, planeta2):
    '''
    V naší sluneční soustavě je osm planet: ta nejblíže Slunci
    je Merkur, další je Venuše, pak Země, Mars, Jupiter, Saturn,
    Uran, Neptun.
    Napište funkci, která vezme dvě jména planet jako řetězce planet1 a planet2.
    Funkce by měla vrátit n-tici obsahující všechny planety, jejichž oběžné dráhy jsou
    nachází se mezi oběžnou dráhou planety1 a oběžnou dráhou planety2, seřazeno podle
    blízkost slunce.
    Funkce by měla vrátit prázdnou n-tici, pokud planeta1 nebo planeta2
    nejsou správná jména planet.
    Příklady
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")


def sorted_list_sum(lst):
    """Napište funkci, která akceptuje seznam řetězců jako parametr,
    odstraní z něj řetězce, které mají lichou délku,
    a vrátí výsledný seznam seřazený podle pravidel,
    Seznam je vždy seznam řetězců a nikdy pole čísel,
    a může obsahovat duplikáty.
    Pořadí seznamu by mělo být vzestupné podle délky každého slova a seznam by měl být seřazený podle tohoto pravidla.
    Pokud mají dvě slova stejnou délku, seřaďte seznam podle abecedy.
    Funkce by měla vrátit seznam řetězců v seřazeném pořadí.
    Můžete předpokládat, že všechna slova budou mít stejnou délku.
    Například:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Napište funkci, která akceptuje seznam řetězců jako parametr,
    odstraní z něj řetězce, které mají liché délky,
    a vrátí výsledný seznam se seřazeným pořadím,
    Seznam je vždy seznam řetězců a nikdy pole čísel,
    a může obsahovat duplikáty.
    Pořadí seznamu by mělo být vzestupné podle délky každého slova a vás
    by měl vrátit seznam seřazený podle tohoto pravidla.
    Pokud mají dvě slova stejnou délku, seřaďte seznam podle abecedy.
    Funkce by měla vrátit seznam řetězců v seřazeném pořadí.
    Můžete předpokládat, že všechna slova budou mít stejnou délku.
    Například:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Napište funkci, která přijme seznam jako parametr,
    odstraní řetězce s lichou délkou,
    vrátí výsledný seznam v seřazeném pořadí,
    seznam je vždy seznam řetězců, nikoliv číselné pole,
    může obsahovat duplicity.
    Pořadí seznamu musí být vzestupně podle délky každého slova,
    a musí vrátit seznam seřazený podle tohoto pravidla.
    Pokud je délka dvou slov stejná, seřaďte seznam podle abecedního pořadí.
    Funkce musí vrátit seznam řetězců seřazených podle pořadí.
    Můžete předpokládat, že délka všech slov je stejná.
    Příklad:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Jednoduchý program, který by měl vrátit hodnotu x, pokud n je
    prvočíslo a jinak by měl vrátit hodnotu y.

    Příklady:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Jednoduchý program, který by měl vrátit hodnotu x, pokud je n prvočíslo, a měl by vrátit hodnotu y jinak.

    Příklad:
    x_or_y(7, 34, 12) == 34
    x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Jednoduchý program, který by měl vrátit hodnotu x, pokud n je
    prvočíslo a v opačném případě by měla vrátit hodnotu y.

    Příklady:
    pro x_or_y(7, 34, 12) == 34
    pro x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Vrátí součet druhých mocnin lichých čísel v daném seznamu čísel.
    Ignoruje záporná čísla nebo necelá čísla.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Pokud je vstupní seznam prázdný, vrátí 0.
    '''

def double_the_difference(lst):
    '''
    Vzhledem k seznamu čísel vraťte součet druhých mocnin čísel
    v seznamu, které jsou liché. Ignorujte čísla, která jsou záporná nebo nejsou celá.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Pokud je seznam vstupů prázdný, vraťte 0.
    '''

def double_the_difference(lst):
    '''
    Na základě seznamu čísel vrátí součet druhých mocnin čísel
    v seznamu, které jsou liché. Ignorujte čísla, která jsou záporná nebo nejsou celá čísla.

    double_the_difference([1, 3, 2, 0]) == 1 + 9 + 0 + 0 = 10
    double_the_difference([-1, -2, 0]) == 0
    double_the_difference([9, -2]) == 81
    double_the_difference([0]) == 0

    Pokud je vstupní seznam prázdný, vrátí hodnotu 0.
    '''


def compare(game,guess):
    """Všichni si pamatujeme pocit, když je konečně oznámen výsledek události, na kterou jsme dlouho čekali.
    Emoce a myšlenky v tom okamžiku jsou rozhodně hodné zaznamenání a porovnání.
    Vaším úkolem je zjistit, zda někdo přesně předpověděl výsledky mnoha zápasů.
    Jsou poskytnuty dva pole stejné délky, každý index představuje jeden zápas: jedno pole skóre a jedno pole předpovědí.
    Vrátí pole stejné délky, které vyjadřuje míru odchylky každé předpovědi. Pokud je předpověď přesná,
    hodnota je 0, jinak je hodnota absolutní rozdíl mezi předpovědí a skóre.

    Příklad:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Myslím, že si všichni pamatujeme ten pocit, když výsledek nějakého dlouho očekávaného
    výsledek nějaké dlouho očekávané události je konečně známý. Pocity a myšlenky, které v tu chvíli máte, jsou
    rozhodně stojí za zmínku a srovnání.
    Vaším úkolem je určit, zda osoba správně uhádla výsledky několika zápasů.
    Dostanete dvě pole skóre a odhadů stejné délky, kde každý index představuje zápas.
    Vraťte pole stejné délky, které označuje, jak daleko byl každý odhad. Pokud uhodli správně,
    hodnota je 0, a pokud ne, hodnota je absolutní rozdíl mezi odhadem a skóre.

    příklad:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """

def compare(game,guess):
    """Myslím, že si všichni pamatujeme ten pocit, když je výsledek nějaké dlouho očekávané události konečně známý. Pocity a myšlenky, které máte v tu chvíli, rozhodně stojí za to si je poznamenat a porovnat. Vaším úkolem je zjistit, zda osoba správně uhodla výsledky několika zápasů. Dostanete dvě pole skóre a odhadů stejné délky, kde každý index ukazuje na zápas. Vrátíte pole stejné délky, které ukazuje, jak daleko byl každý odhad. Pokud uhodli správně, hodnota je 0, a pokud ne, hodnota je absolutní rozdíl mezi odhadem a skóre.

    příklad:

    compare([1,2,3,4,5,1],[1,2,3,4,2,-2]) -> [0,0,0,0,3,3]
    compare([0,5,0,0,0,4],[4,1,1,0,0,-2]) -> [4,4,1,0,0,6]
    """


def Strongest_Extension(class_name, extensions):
    """Název třídy (řetězec) a seznam rozšíření jsou poskytnuty.
    Rozšíření se používají k načtení dalších tříd do třídy.
    Síla rozšíření se počítá následovně: CAP je počet velkých písmen v názvu rozšíření,
    SM je počet malých písmen v názvu rozšíření, síla je dána rozdílem CAP - SM.
    Je třeba najít nejsilnější rozšíření a vrátit řetězec ve formátu:
    ClassName.StrongestExtensionName.
    Pokud existují dvě rozšíření se stejnou silou, vyberte to, které se objeví dříve v seznamu.
    Například, s třídou "Slices" a seznamem rozšíření ['SErviNGSliCes', 'Cheese', 'StuFfed'],
    'SErviNGSliCes' je nejsilnější rozšíření, takže vrátí 'Slices.SErviNGSliCes'
    (síla je -1).
    Příklad:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Dostanete název třídy (řetězec) a seznam rozšíření.
    Rozšíření se mají použít k načtení dalších tříd do třídy. Síla rozšíření je následující: Nechť CAP je číslo velkých písmen
    v názvu rozšíření a nechť SM je počet malých písmen
    v názvu rozšíření. Síla je dána zlomkem CAP - SM.
    Měli byste najít nejsilnější rozšíření a vrátit řetězec v tomto
    formátu: ClassName.StrongestExtensionName.
    Pokud existují dvě nebo více rozšíření se stejnou silou, měli byste
    vybrat to, které je v seznamu první.
    Například, pokud dostanete jako třídu "Slices" a seznam
    rozšíření: ['SErviNGSliCes', 'Cheese', 'StuFfed'] pak byste měli
    vrátit 'Slices.SErviNGSliCes', protože 'SErviNGSliCes' je nejsilnější rozšíření
    (jeho síla je -1).
    Příklad:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Dostanete název třídy (řetězec) a seznam rozšíření.
    Rozšíření se mají použít k načtení dalších tříd do třídy. The
    síla rozšíření je následující: Nechť CAP je počet velkých písmen
    v názvu rozšíření a nechť SM je počet malých písmen
    síla je dána rozdílem CAP - SM.
    Měli byste najít nejsilnější rozšíření a vrátit řetězec ve
    formátu: ClassName.StrongestExtensionName
    Pokud existují dvě nebo více nástavců se stejnou silou, měli byste
    vyberte ten, který je v seznamu první.
    Například, pokud dostanete jako třídu "Slices" a seznam
    rozšíření: ['SErviNGSliCes', 'Cheese', 'StuFfed'] pak byste měli
    vrátit 'Slices.SErviNGSliCes', protože 'SErviNGSliCes' je nejsilnější rozšíření
    (jeho síla je -1).
    Příklad:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """Jsou vám dána 2 slova. Pokud je druhé slovo nebo jakákoliv jeho rotace podřetězcem v prvním slově, musíte vrátit hodnotu True
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    ""Jsou vám dána 2 slova. Je nutné vrátit hodnotu True, pokud je druhé slovo nebo některé z jeho otočení podřetězcem v prvním slově
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Dostanete dvě slova.Pokud je druhé slovo nebo některá z jeho permutací částí prvního slova, vrátí True.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Je dáno celé číslo. Vrátí tupl, která má počet sudých a lichých číslic čísla.

    Příklad:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Dané celé číslo. vrátí n-tici, která má počet sudých a lichých číslic.

     Příklad:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Když je zadáno celé číslo, vrátí n-tici obsahující počet sudých a lichých číslic.

     Příklad:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Vzhledem k kladnému celému číslu získejte jeho ekvivalent římského čísla jako řetězec,
    a vraťte jej malými písmeny.
    Omezení: 1 <= num <= 1000

    Příklady:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Pokud je zadáno kladné celé číslo, získá odpovídající řetězec římských číslic
    a vrátí jej ve formě malých písmen.
    Podmínka omezení: 1 <= num <= 1000

    Příklad:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Zadané délky tří stran trojúhelníku. Vraťte True, pokud tři
    strany tvoří pravoúhlý trojúhelník, jinak False.
    Pravoúhlý trojúhelník je trojúhelník, ve kterém je jeden úhel pravý úhel, resp.
    90 stupňů.
    Příklad:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Když jsou dány délky tří stran trojúhelníku, pokud tyto tři strany tvoří pravoúhlý trojúhelník, vrátí True,
    jinak vrátí False.
    Pravoúhlý trojúhelník je trojúhelník, který má jeden pravý úhel nebo 90 stupňů.
    Příklad:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Napište funkci, která přijímá seznam řetězců.
    Seznam obsahuje různé slova. Vrátí slovo s největším počtem unikátních znaků.
    Pokud existuje více řetězců s největším počtem unikátních znaků,
    vrátí řetězec, který se objeví dříve podle abecedního pořadí.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """

def find_max(words):
    """Napište funkci, která přijímá seznam řetězců.
    Seznam obsahuje různá slova. Vraťte slovo s maximálním počtem
    jedinečných znaků. Pokud má více řetězců maximální počet jedinečných
    znaků, vraťte ten, který je první v lexikografickém pořadí.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == "aaaaaaa"
    """

def find_max(words):
    """Napište funkci, která přijímá seznam řetězců.
    Seznam obsahuje různá slova. Vraťte slovo s maximálním počtem
    jedinečných postav. Pokud má více řetězců maximální počet jedinečných
    znaků, vraťte ten, který je první v lexikografickém pořadí.

    find_max(["name", "of", "string"]) == "string"
    find_max(["name", "enam", "game"]) == "enam"
    find_max(["aaaaaaa", "bb" ,"cc"]) == ""aaaaaaa"
    """


def eat(number, need, remaining):
    """
    Jste hladový králík a už jste snědli určitý počet mrkví,
    Nyní však musíte sníst více mrkve, abyste dokončili denní jídla.
    měli byste vrátit pole [ celkový počet snědených mrkví po jídle,
                                    počet mrkví, které vám zbyly po jídle ]
    Pokud nezbude dostatek mrkve, sníte veškerou zbývající mrkev, ale stále budete mít hlad.

    Příklad:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Proměnné:
    @number : celé číslo
        počet mrkví, které jste snědli.
    @need : celé číslo
        počet mrkví, které musíte sníst.
    @remaining : celé číslo
        Počet mrkví, které zbývají na skladě

    Omezit:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Bavte se :)
    """

def eat(number, need, remaining):
    """
    Jsi hladový králík a už jsi snědl určitý počet mrkví,
    ale nyní musíš jíst více mrkve, abys dokončil denní jídlo.
    Měli byste po jídle vrátit seznam [ celkový počet snědených mrkví,
                                       počet mrkví, které vám zbyly po jídle ]
    pokud nezbude dostatek mrkve, sníte všechny zbývající mrkve, ale stále budete mít hlad.

    Příklad:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Proměnné:
    @number : celé číslo
        počet mrkví, které jsi už snědl.
    @need : celé číslo
        počet mrkví, které ještě potřebuješ sníst.
    @remaining : celé číslo
        počet mrkví, které ti ještě zůstávají v zásobě

    Omezení:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Užijte si to :)
    """

def eat(number, need, remaining):
    """
    Jste hladový králík, který již snědl určité množství mrkve,
    ale nyní potřebuje sníst více mrkve, aby dokončil denní jídlo.
    Musíte vrátit pole [ celkový počet mrkví snědených po jídle,
                         počet mrkví zbývajících po jídle ].
    Pokud zbývající mrkve nejsou dostatečné, sníte všechny zbývající mrkve, ale stále budete hladoví.

    Příklad:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Proměnné:
    @number : celé číslo
        Počet mrkví, které jste již snědli.
    @need : celé číslo
        Počet mrkví, které potřebujete sníst.
    @remaining : celé číslo
        Počet mrkví zbývajících na skladě

    Podmínky:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Dobrou chuť :)
    """


def do_algebra(operator, operand):
    """
    Jsou dány dva seznamy: operator a operand. První seznam obsahuje základní algebraické operace
    a druhý seznam obsahuje seznam celých čísel. Použijte tyto dva seznamy k vytvoření algebraického
    výrazu a vraťte výsledek vyhodnocení tohoto výrazu.

    Základní algebraické operace:
    Sčítání ( + )
    Odčítání ( - )
    Násobení ( * )
    Dělení ( // )
    Mocnina ( ** )

    Příklad:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Poznámka:
        Délka seznamu operator je o jednu menší než délka seznamu operand.
        operand je seznam nezáporných celých čísel.
        Seznam operator obsahuje alespoň jeden operátor a seznam operand obsahuje alespoň dva operandy.

    """

def do_algebra(operator, operand):
    """
    Dány dva seznamy, operátor, a operand. První seznam obsahuje základní algebraické operace a
    druhý seznam je seznam celých čísel. Použijte dva uvedené seznamy k vytvoření algebraického
    výrazu a vrátí vyhodnocení tohoto výrazu.

    Základní algebraické operace:
    Sčítání ( + )
    Odčítání ( - )
    Násobení ( * )
    Celkové dělení ( // )
    Mocnina ( ** )

    Příklad:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Poznámka:
        Délka seznamu operátorů se rovná délce seznamu operandů mínus jedna.
        Operand je seznam nezáporných celých čísel.
        Seznam operátorů má alespoň jeden operátor a seznam operandů má alespoň dva operandy.

    """

def do_algebra(operator, operand):
    """
    Jsou dány dva seznamy operátor a operand. První seznam obsahuje základní algebraické operace a
    druhý seznam je seznam celých čísel. Pomocí dvou uvedených seznamů sestavte algebriku
    výraz a vrátí vyhodnocení tohoto výrazu.

    Základní operace algebry:
    Addition ( + )
    Subtraction ( - )
    Multiplication ( * )
    Floor division ( // )
    Exponentiation ( ** )

    Příklad:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Poznámka:
        Délka seznamu operátorů se rovná délce seznamu operandů mínus jedna.
        Operand je seznam nezáporných celých čísel.
        Seznam operátorů má alespoň jednoho operátora a seznam operandů má alespoň dva operandy.

    """


def solve(s):
    """Řetězec s je poskytnut.
    Pokud je s[i] písmeno, převeďte malá písmena na velká nebo naopak,
    pokud ne, ponechte beze změny.
    Pokud řetězec neobsahuje žádná písmena, otočte řetězec.
    Funkce musí vrátit výsledný řetězec.
    Příklady
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Je vám dán řetězec s.
    je-li s[i] písmeno, přehoďte jeho velká a malá písmena z dolní na horní nebo naopak,
    jinak to nech tak jak to je.
    Pokud řetězec neobsahuje žádná písmena, obraťte řetězec.
    Funkce by měla vrátit výsledný řetězec.
    Příklady
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Dostanete řetězec s.
    je-li s[i] písmeno, obraťte jeho velikost písmen z dolního na horní nebo naopak,
    jinak to ponechte tak, jak to je.
    Pokud řetězec neobsahuje žádná písmena, obraťte řetězec.
    Funkce by měla vrátit výsledný řetězec.
    Příklady
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    Pro zadaný řetězec 'text' vrátí jeho md5 hash.
    Pokud je 'text' prázdný řetězec, vrátí None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Vzhledem k řetězci 'text' vraťte jeho ekvivalentní řetězec md5 hash.
    Pokud je 'text' prázdný řetězec, vraťte None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """

def string_to_md5(text):
    """
    Pokud je zadán řetězec 'text', vrátí jeho md5 hash řetězec.
    Pokud je 'text' prázdný řetězec, vrátí None.

    >>> string_to_md5('Hello world') == '3e25960a79dbc69b674cd4ec67a72c62'
    """


def generate_integers(a, b):
    """
    Pro dvě kladná celá čísla a a b, vrátí sudá čísla mezi a a b v rostoucím pořadí.

    Příklad:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Zadaná dvě kladná celá čísla a a b, vraťte sudé číslice mezi a a b, ve vzestupném pořadí.

    For example:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Zadaná jsou dvě kladná celá čísla a a b, vraťte mezi a sudá čísla
    a b, ve vzestupném pořadí.

    Například:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """