from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Zkontrolujte, zda v daném seznamu čísel existují dvě čísla, která jsou blíže k sobě než daný práh.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Zkontrolujte, zda v daném seznamu čísel nejsou nějaká dvě čísla blíže k sobě než
    než prahová hodnota.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Zkontrolujte, zda v daném seznamu čísel jsou jakákoli dvě čísla blíže k sobě než
    daný práh.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Vstupem do této funkce je řetězec obsahující více skupin vnořených závorek. Vaším cílem je
    rozdělit tyto skupiny do samostatných řetězců a vrátit jejich seznam.
    Jednotlivé skupiny jsou vyvážené (každá otevřená závorka je správně uzavřena) a nejsou vnořeny do sebe.
    Ignorujte mezery ve vstupním řetězci.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> Seznam[str]:
    """Vstupem této funkce je řetězec obsahující více skupin vnořených závorek. Vaším cílem je
    Tyto skupiny rozdělte do samostatných řetězců a vraťte jejich seznam.
    Samostatné skupiny jsou vyvážené (každá otevřená složená závorka je správně uzavřená) a nejsou do sebe vnořeny
    Ignorujte všechny mezery ve vstupním řetězci.
    >>> separate_paren_groups('( ) (( )) (( )( )))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Vstupem této funkce je řetězec obsahující více skupin závorek vnořených do sebe. Cílem je
    oddělit tyto skupiny do jednotlivých řetězců a vrátit tento seznam.
    Jednotlivé skupiny jsou vyvážené (každá otevírací závorka je správně uzavřena) a nejsou vnořené do sebe.
    Mezery v vstupním řetězci jsou ignorovány.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Pokud je zadáno kladné desetinné číslo, může být rozděleno na celou část
    (největší celé číslo menší než zadané číslo) a desetinnou část (zbytek, který je vždy menší než 1).

    Vrátí desetinnou část čísla.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Vzhledem ke kladnému číslu s plovoucí desetinnou čárkou jej lze rozložit na
    a celočíselná část (největší celé číslo menší než zadané číslo) a desetinná místa
    (zbytková část je vždy menší než 1).

    Vrátí desetinnou část čísla.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Pro kladné číslo s desetinnou čárkou, lze jej rozložit na
    a celočíselná část (největší celé číslo menší než dané číslo) a desetinná část
    (zbytková část vždy menší než 1).

    Vraťte desetinnou část čísla.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Dostanete seznam vkladových a výběrových operací na bankovním účtu, který začíná na
    nulový zůstatek. Vaším úkolem je zjistit, zda v kterémkoli okamžiku stav účtu klesne pod nulu, a
    v tomto bodě by funkce měla vrátit True. Jinak by měl vrátit False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Je poskytnut seznam operací vkladu a výběru z bankovního účtu.
    Účet začíná se zůstatkem 0.
    Úkolem je zjistit, kdy zůstatek účtu klesne pod 0,
    a v tom okamžiku by funkce měla vrátit True. Jinak vrátí False.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Vypočítá průměrnou absolutní odchylku pro zadaný seznam čísel,
    kde středem této datové sady je průměr.
    Průměrná absolutní odchylka je průměr absolutních odchylek mezi každým prvkem a středem (v tomto případě průměrem):
    MAD = průměr | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ Pro daný seznam vstupních čísel vypočítejte střední absolutní odchylku
    kolem průměru této datové sady.
    Střední absolutní odchylka je průměrný absolutní rozdíl mezi nimi
    prvek a střed (v tomto případě znamená):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Vloží číslo 'delimeter' mezi dva po sobě jdoucí prvky v zadaném seznamu `numbers`.
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Mezi každé dva po sobě jdoucí prvky seznamu numbersvložte číslodelimeter` jako oddělovač.
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Vložit číslo "oddělovač" mezi každé dva po sobě jdoucí prvky vstupního seznamu "čísla"
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Vstupem této funkce je řetězec představující více skupin vnořených závorek oddělených mezerou.
    Pro každou skupinu vrátí nejhlubší úroveň vnoření závorek.
    Například: (()()) má maximálně dvě úrovně vnoření a ((())) má tři úrovně vnoření.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """Vstupem do této funkce je řetězec reprezentovaný několika skupinami pro vnořené závorky oddělené mezerami.
    Pro každou skupinu vypíše nejhlubší úroveň vnoření závorek.
    Např. (()()) má maximálně dvě úrovně vnoření, zatímco ((())) má tři.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Vstupem do této funkce je řetězec reprezentovaný více skupinami pro vnořené závorky oddělené mezerami.
    Pro každou skupinu zadejte nejhlubší úroveň vnoření závorek.
    Např. (()()) má maximálně dvě úrovně vnoření, zatímco ((())) má tři.

    >>> parse_nested_parens('(()()) ((())) () ((())()())')
    [2, 3, 1, 3]
    """


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtrování seznamu vstupních řetězců tak, aby zůstaly pouze řetězce obsahující daný podřetězec.
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtrovat vstupní seznam řetězců pouze pro ty, které obsahují daný podřetězec
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Filtrujte vstupní seznam řetězců pouze pro ty, které obsahují daný podřetězec
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Vrátí dvojici hodnot, která obsahuje součet a součin všech celých čísel v daném seznamu.
    Součet prázdného seznamu musí být 0 a součin prázdného seznamu musí být 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(čísla: Seznam[int]) -> Tuple[int, int]:
    """ Pro daný seznam celých čísel vraťte n-tici sestávající ze součtu a součinu všech celých čísel v seznamu.
    Prázdný součet by se měl rovnat 0 a prázdný součin by se měl rovnat 1.
     >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Pro daný seznam celých čísel vraťte n-tici sestávající ze součtu a součinu všech celých čísel v seznamu.
    Prázdný součet by se měl rovnat 0 a prázdný součin by se měl rovnat 1.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Vytvořte seznam posuvných maximálních prvků nalezených až do aktuálního bodu v dané posloupnosti celých čísel.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Z daného seznamu celých čísel vygenerujte seznam prvků pohyblivého maxima nalezených do daného okamžiku
    v pořadí.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Z daného seznamu celých čísel vygenerujte seznam klouzavých maximálních prvků nalezených do daného okamžiku
    v sekvenci.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Otestujte, zda je daný řetězec palindrom """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Najděte nejkratší palindrom, který začíná dodaným řetězcem.
    Myšlenka algoritmu je jednoduchá:
    - Najděte nejdelší postfix dodaného řetězce, který je palindrom.
    - Připojte na konec řetězce obrácenou předponu řetězce, která je před palindromickou příponou.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Otestujte, zda daný řetězec je palindrom """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Najděte nejkratší palindrom, který začíná dodaným řetězcem.
    Myšlenka algoritmu je jednoduchá:
    - Najděte nejdelší postfix dodaného řetězce, kterým je palindrom.
    - Připojte na konec řetězce obrácenou předponu řetězce, která je před palindromickou příponou.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Zkontrolujte, zda je daný řetězec palindrom """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Najděte nejkratší palindrom začínající daným řetězcem.
    Myšlenka algoritmu je velmi jednoduchá:
    - Najděte nejdelší sufix daného řetězce, který je palindrom.
    - Přidejte obrácený prefix řetězce před palindromický sufix na konec řetězce.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ Vstupem jsou dva řetězce a a b, které obsahují pouze 1 a 0.
    Proveďte binární XOR na těchto vstupech a vraťte výsledek jako řetězec.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Vstup jsou dva řetězce a a b, které se skládají pouze z 1 a 0.
    Proveďte binární XOR na těchto vstupech a vraťte výsledek také jako řetězec.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Vstupem jsou dva řetězce a a b skládající se pouze z 1s a 0s.
    Proveďte binární XOR na těchto vstupech a vraťte výsledek také jako řetězec.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Vrátí nejdelší řetězec ze seznamu řetězců. Pokud existuje více řetězců se stejnou délkou,
    vrátí první řetězec. Pokud je vstupní seznam prázdný, vrátí None.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Ze seznamu řetězců vrátí ten nejdelší. Vrátit první v případě více řetězců stejné délky. Vrátit None v případě, že je vstupní seznam prázdný.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Ze seznamu řetězců vraťte nejdelší řetězec. V případě více položek vraťte první
    řetězce stejné délky. Vraťte None v případě, že je seznam vstupů prázdný.
    >>> longest([])

    >>> longest(['a', 'b', 'c'])
    'a'
    >>> longest(['a', 'bb', 'ccc'])
    'ccc'
    """.


def greatest_common_divisor(a: int, b: int) -> int:
    """ Vrátí největší společný dělitel dvou celých čísel a a b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Vraťte největšího společného dělitele dvou celých čísel a a b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Vrátí největšího společného dělitele dvou celých čísel a a b
    >>>greatest_common_divisor(3, 5)
    1
    >>>greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Zadaný řetězec vrátí seznam všech předpon od nejkratší po nejdelší.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Vrátí seznam všech prefixů od nejkratšího po nejdelší ze vstupního řetězce
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Vrátí seznam všech předpon od nejkratšího po nejdelší ze vstupního řetězce
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Vrátí řetězec obsahující čísla od 0 do n včetně, oddělená mezerou.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Vrátí řetězec obsahující čísla oddělená mezerou počínaje 0 až n včetně.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Vrátí řetězec obsahující čísla oddělená mezerami počínaje 0 až n včetně.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Zjistěte, kolik různých znaků (bez rozlišení velkých a malých písmen) je v daném řetězci
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Zadaný řetězec zjistěte, kolik různých znaků (nezávisle na velikosti písmen) obsahuje
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Vstupem do této funkce je řetězec představující hudební noty ve speciálním formátu ASCII.
    Vaším úkolem je analyzovat tento řetězec a vrátit seznam celých čísel odpovídajících tomu, kolik doby trvá každá nota.

    Zde je legenda:
    'o' - celá nota, trvá čtyři doby
    'o|' - půlnota, trvá dvě doby
    '.|' - čtvrťová nota, trvá jednu dobu

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Tato funkce přijímá vstupní řetězec, který reprezentuje noty ve speciálním ASCII formátu.
    Úkolem je analyzovat tento řetězec a vrátit seznam celých čísel, která reprezentují, kolik dob každá nota trvá.

    Legenda je následující:
    'o' - celá nota, trvá 4 doby
    'o|' - půlová nota, trvá 2 doby
    '.|' - čtvrťová nota, trvá 1 dobu

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Vstupem do této funkce je řetězec představující hudební noty ve speciálním formátu ASCII.
    Vaším úkolem je analyzovat tento řetězec a vrátit seznam celých čísel odpovídajících tomu, kolik úderů každá nota trvá.

    Zde je legenda:
    'o' - whole note, lasts four beats
    'o|' - half note, lasts two beats
    '.|' - quater note, lasts one beat

    >>> parse_music('o o| .| o| o| .| .| .| .| o o')
    [4, 2, 1, 2, 2, 1, 1, 1, 1, 4, 4]
    """


def how_many_times(string: str, substring: str) -> int:
    """ Zjistěte, kolikrát lze daný podřetězec nalézt v původním řetězci. Počítejte překrývající se případy.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Zjistěte, kolikrát lze daný podřetězec nalézt v původním řetězci. Počítá překrývající se případy.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ Vstupem je řetězec čísel od 'zero' do 'nine' oddělený mezerou.
    Platné možnosti jsou 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'.
    Vrátí řetězec čísel seřazených od nejmenšího po největší.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Vstup je mezerou oddělený řetězec čísel od 'nuly' do 'devítky'.
    Platné možnosti jsou 'nula', 'jedna', 'dva', 'tři', 'čtyři', 'pět', 'šest', 'sedm', 'osm' a 'devět'.
    Vraťte řetězec s čísly seřazenými od nejmenšího po největší.

    Příklad:
    >>> sort_numbers('tři jedna pět')
    'jedna tři pět'
    """

from typing import List

def sort_numbers(čísla: str) -> str:
    """ Vstup je mezerou oddělený řetězec čísel od'zero' do 'nine' .
    Platné možnosti jsou 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'.
    Vraťte řetězec s čísly seřazenými od nejmenšího po největší
    >>> sort_numbers('three one five')
    "one three five"
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Vyberte dvě nejbližší čísla ze zadaného seznamu čísel (s délkou alespoň dva)
    a vraťte je v pořadí menší číslo, větší číslo.
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Z dodaného seznamu čísel (o délce alespoň dvě) vyberte a vraťte dvě, která jsou nejblíže k sobě a vraťte je v pořadí (menší počet, větší počet).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Z dodaného seznamu čísel (o délce alespoň dvě) vyberte a vraťte dvě, která jsou každému nejblíže
    jiné a vraťte je v pořádku (menší počet, větší počet).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Pokud je zadán seznam čísel s alespoň dvěma prvky, použijte lineární transformaci,
    aby se nejmenší číslo stalo 0 a největší číslo stalo 1.
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Daný seznam čísel (alespoň dvou prvků) aplikujte na tento seznam lineární transformaci,
    tak, že nejmenší číslo bude 0 a největší bude 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrování pouze celých čísel ze zadaného seznamu hodnot Pythonu
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtrujte daný seznam všech hodnot Pythonu pouze pro celá čísla
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ Filtruje daný seznam libovolných hodnot Pythonu pouze pro celá čísla
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Vrátí délku daného řetězce
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Vrátí délku zadaného řetězce
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Pro dané číslo n najděte největší číslo, které dělí n beze zbytku, menší než n
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Najděte největší číslo menší než n, kterým je n dělitelné.
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Vrátí prvočíselné faktory daného celého čísla v pořadí od nejmenšího po největší.
    Každý faktor musí být uveden podle počtu výskytů v prvočíselném rozkladu.
    Vstupní číslo musí být rovno součinu všech faktorů.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Vrátí seznam prvočísel daného celého čísla v pořadí od nejmenšího po největší.
    Každý z faktorů by měl být uveden tolikrát, kolikrát odpovídá tomu, kolikrát se vyskytuje v faktorizaci.
    Vstupní číslo by se mělo rovnat součinu všech faktorů
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Vrátí seznam prvočísel daného celého čísla v pořadí od nejmenšího po největší.
    Každý z faktorů by měl být uveden tolikrát, kolikrát odpovídá tomu, kolikrát se vyskytuje v faktorizaci.
    Vstupní číslo by se mělo rovnat součinu všech faktorů
    >>> faktorizovat(8)
    [2, 2, 2]
    >>> faktorizovat(25)
    [5, 5]
    >>> faktorizovat (70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Ze seznamu celých čísel odeberte všechny prvky, které se vyskytují více než jednou.
    Zachovejte pořadí prvků stejné jako ve vstupu.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Ze seznamu celých čísel odeberte všechny prvky, které se vyskytují více než jednou.
    Zachovejte pořadí prvků vlevo stejné jako ve vstupu.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Odstraní všechny prvky, které se v seznamu celých čísel objevují více než jednou.
    Zachová pořadí zbývajících prvků jako ve vstupu.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Pro daný řetězec přehoďte malá písmena na velká a velká na malá.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Pro daný řetězec překlopte malá písmena na velká a velká na malá.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Pro daný řetězec převeďte malá písmena na velká a velká písmena na malá.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Zřetězit seznam řetězců do jednoho řetězce
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Spojí seznam řetězců do jednoho řetězce
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrovat vstupní seznam řetězců pouze pro ty, které začínají danou předponou.
     >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrování seznamu vstupních řetězců tak, aby zůstaly pouze řetězce začínající danou předponou.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Filtrujte vstupní seznam řetězců pouze pro ty, které začínají danou předponou.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Vrátí pouze kladná čísla v seznamu.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """Vraťte pouze kladná čísla v seznamu.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """Vrátí true, pokud je dané číslo prvočíslo, jinak vrátí false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Pokud je dané číslo prvočíslo, vrátí hodnotu true a v opačném případě vrátí hodnotu false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    ""Vrátí hodnotu true, pokud je dané číslo prvočíslo, v opačném případě hodnotu false.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Koeficienty xs polynomu jsou vyhodnoceny v bodě x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs jsou koeficienty polynomu.
    find_zero hledá x, pro které platí poly(x) = 0.
    find_zero vrátí pouze jedno řešení, i když existuje více řešení.
    Dále, find_zero přijímá pouze seznam xs s sudým počtem koeficientů
    a s největším nenulovým koeficientem.
    To zaručuje řešení.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Vyhodnotí polynom s koeficienty xs v bodě x.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs jsou koeficienty polynomu.
    find_zero najdi x takové, že poly(x) = 0.
    find_zero vrátí pouze nulový bod, i když jich je mnoho.
    Navíc find_zero bere pouze seznam xs se sudým počtem koeficientů
    a největší nenulový koeficient, jaký zaručuje
    řešení.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Vyhodnotí polynom s koeficienty xs v bodě x.
    Vrátí xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs jsou koeficienty polynomu. find_zero najde x, takové že poly(x) = 0. find_zero vrací pouze nulu, i když jich může být více. Navíc, find_zero přijímá pouze seznam xs se sudým počtem koeficientů a největším nenulovým koeficientem, protože to zaručuje existenci řešení.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Tato funkce přijímá seznam l a vrací seznam l'.
    l' je stejný jako l na indexech, které nejsou dělitelné 3, a hodnoty na indexech dělitelné 3
    jsou hodnoty na těchto indexech v l seřazené.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: seznam):
    """Tato funkce vezme seznam l a vrátí seznam l' takový, že
    l' je shodné s l v indexech, které nejsou dělitelné třemi, zatímco jeho hodnoty u indexů, které jsou dělitelné třemi, jsou stejné
    na hodnoty odpovídajících indexů l, ale seřazené.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Vrátí seřazené jedinečné prvky v seznamu
    >>>  unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Vrátí jedinečné prvky seřazené ze seznamu
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Vrátit seřazené unikátní prvky seznamu
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Vrátí největší prvek v seznamu.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """Vrátí maximum prvku v seznamu.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Vrátí počet výskytů čísla 7 v celých číslech menších než n, která jsou dělitelná 11 nebo 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Vraťte, kolikrát se číslice 7 vyskytuje v celých číslech menších než n, která jsou dělitelná 11 nebo 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Vrátí počet výskytů číslice 7 v celých číslech menších než n, která jsou dělitelná 11 nebo 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Tato funkce přijímá seznam l a vrací seznam l'.
    l' je stejný jako l na lichých indexech a hodnoty na sudých indexech
    jsou hodnoty na sudých indexech z l, které byly seřazeny.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Tato funkce vezme seznam l a vrátí seznam l' takový, že
     l' je identický s l u lichých indexů, zatímco jeho hodnoty u sudých indexů jsou stejné
    na hodnoty sudých indexů l, ale seřazené.
     >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def set_even(l: seznam):
    """Tato funkce vezme seznam l a vrátí seznam l' takový, že
    l' je identický s l u lichých indexů, zatímco jeho hodnoty u sudých indexů jsou stejné
    na hodnoty sudých indexů l, ale seřazené.
    >>>sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    Vrátí zakódovaný řetězec vytvořený cyklickým posunutím skupin po třech znacích.
    """
    # Rozdělte řetězec na skupiny, přičemž každá skupina má délku 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Cyklicky posuňte prvky každé skupiny. Vynechejte skupiny s méně než 3 prvky.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Přijme zakódovaný řetězec z funkce encode_cyclic jako vstup a vrátí původní řetězec.
    """

def encode_cyclic(s: str):
    """
    vrací zakódovaný řetězec cyklováním skupin po třech znacích.
    """
    # split string to groups. Each of length 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycle elements in each group. Unless group has fewer elements than 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    bere jako vstupní řetězec zakódovaný funkcí encode_cyclic. Vrátí dekódovaný řetězec.
    """

def encode_cyclic(s: str):
    """
    Tři skupiny znaků jsou cyklicky posunuty, aby se vrátil zakódovaný řetězec.
    """
    # Rozdělte řetězec na skupiny. Každá skupina má délku 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Cyklicky posuňte prvky každé skupiny. Vynechejte skupiny s méně než 3 prvky.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Přijme zakódovaný řetězec z funkce encode_cyclic jako vstup a vrátí dekódovaný řetězec.
    """


def prime_fib(n: int):
    """
    prime_fib vrátí n-té číslo, které je Fibonacciho číslem a je také prvočíslo.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib vrátí n-té číslo, které je současně Fibonacciho číslem a prvočíslem.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib vrací n-té číslo, které je Fibonacciho číslem a je také prvočíslo.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    Funkce triples_sum_to_zero přijímá seznam celých čísel jako vstup.
    Pokud seznam obsahuje tři různé prvky, jejichž součet je 0, vrátí True,
    jinak vrátí False.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero bere jako vstup seznam celých čísel.
    vrátí True, pokud jsou v seznamu tři odlišné prvky,
    jejichž součet je nula, a jinak False.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero bere jako vstup seznam celých čísel.
    vrátí True, pokud jsou v seznamu tři odlišné prvky
    jejich součet je nula a jinak False.

    >>> triples_sum_to_zero([1, 3, 5, 0])
    False
    >>> triples_sum_to_zero([1, 3, -2, 1])
    True
    >>> triples_sum_to_zero([1, 2, 3, 7])
    False
    >>> triples_sum_to_zero([2, 4, -5, 3, 9, 7])
    True
    >>> triples_sum_to_zero([1])
    False
    """


def car_race_collision(n: int):
    """
    Představte si, že silnice je dokonalá přímka, která se táhne do nekonečna.
    Je zde n aut jedoucích zleva doprava; současně je zde n aut
    jedoucích zprava doleva. Obě skupiny aut jsou zpočátku velmi daleko od sebe.
    Všechna auta se pohybují stejnou rychlostí. Když se auto jedoucí
    zleva doprava setká s autem jedoucím zprava doleva, nazývá se to srážka.
    Nicméně, auta jsou nesmírně odolná a silná; výsledkem je, že pokračují
    ve své dráze, jako by k žádné srážce nedošlo.

    Tato funkce vrátí počet takových srážek.
    """

def car_race_collision(n: int):
    """
    Představte si silnici, která je dokonale rovná, nekonečně dlouhá čára.
    n aut jezdí zleva doprava; současně jiná sada n vozů
    jezdí zprava doleva. Dvě sady aut začínají být velmi daleko
    navzájem. Všechna auta se pohybují stejnou rychlostí. Říká se, že se srazí dvě auta,
    když auto, které se pohybuje zleva doprava, narazí do auta, které se pohybuje zprava doleva.
    Vozy jsou však nekonečně robustní a silné; v důsledku toho pokračují v pohybu
    ve své dráze, jako by se nesrazily.

    Tato funkce vrátí počet takových kolizí.
    """

def car_race_collision(n: int):
    """
    Představte si silnici, která je dokonale rovná, nekonečně dlouhá čára.
    n auta jezdí zleva doprava;  současně jiná sada n vozů
    jezdí zprava doleva.   Dvě sady aut začínají být velmi daleko
    navzájem.  Všechna auta se pohybují stejnou rychlostí.  Údajně se srazí dvě auta
    když auto, které se pohybuje zleva doprava, narazí do auta, které se pohybuje zprava doleva.
    Vozy jsou však nekonečně robustní a silné; v důsledku toho pokračují v pohybu
    ve své dráze jako by se nesrazily.

    Tato funkce vypíše počet takových kolizí.
    """


def incr_list(l: list):
    """Vrátí seznam s prvky zvýšenými o 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: seznam):
    """Návratový seznam s prvky zvýšenými o 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Návratový seznam s prvky zvýšenými o 1.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero přijímá seznam celých čísel jako vstup.
    Pokud v seznamu existují dva různé prvky, jejichž součet je 0, vrátí True,
    jinak vrátí False.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero bere jako vstup seznam celých čísel.
    vrátí True, pokud jsou v seznamu dva odlišné prvky,
    jejichž součet je nula, a jinak vrátí False.

    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero bere jako vstup seznam celých čísel.
    vrátí True, pokud v seznamu existují dva odlišné prvky
    jejichž součet je nula, a jinak False.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """Změňte číselný základ vstupního čísla x na zadaný základ.
    vrátit reprezentaci řetězce po konverzi.
    základ musí být menší než 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Změňte číselný základ vstupního čísla x na základ.
    vrátit reprezentaci řetězce po konverzi.
    základní čísla jsou menší než 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Změní základ vstupního čísla x na základ.
    Vrátí řetězcovou reprezentaci po konverzi.
    Základ je menší než 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Vzhledem k délce strany a výšce vrátí plochu trojúhelníku.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Zadaná délka strany a výška, vrátí obsah trojúhelníku.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Sekvence Fib4 je podobná Fibonacciho sekvenci a je definována následovně:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Napište funkci pro efektivní výpočet n-tého prvku sekvence Fib4. Nepoužívejte rekurzi.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Číselná sekvence Fib4 je sekvence podobná Fibbonacciho posloupnosti, která je definována takto:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Napište prosím funkci pro efektivní výpočet n-tého prvku číselné řady fib4. Nepoužívejte rekurzi.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Vrátí medián hodnot prvků v seznamu l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Return median of elements in the list l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Zkontrolujte, zda je daný řetězec palindrom
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Zkontroluje, zda daný řetězec je palindrom
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Vraťte 2^n modulo p (pozor na číslice).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Vrátí zbytek z 2^n děleno p (pozor na údaje).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Vraťte 2^n modulo p (pozor na číslice).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0; 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    Vrátí řetězec zakódovaný posunutím každého znaku v abecedě o 5 pozic.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Přijme řetězec zakódovaný funkcí encode_shift jako vstup a vrátí dekódovaný řetězec.
    """

def encode_shift(s: str):
    """
    vrátí kódovaný řetězec posunutím každého znaku o 5 v abecedě.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    bere jako vstupní řetězec zakódovaný funkcí encode_shift. Vrátí dekódovaný řetězec.
    """


def remove_vowels(text):
    """
    remove_vowels je funkce, která vezme řetězec a vrátí řetězec bez samohlásek.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    remove_vowels je funkce, která přijímá řetězec a vrací řetězec bez samohlásek.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Vraťte True, pokud jsou všechna čísla v seznamu l pod prahovou hodnotou t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Vrátí True, pokud jsou všechna čísla v seznamu l menší než práh t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: seznam, t: int):
    """Vrátí hodnotu True, pokud jsou všechna čísla v seznamu l pod prahovou hodnotou t.
     >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Sečte dvě čísla x a y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Sečtěte dvě čísla x a y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Zkontrolujte, zda mají dvě slova stejné znaky.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Vrátí n-té Fibonacciho číslo.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """Vraťte n-té Fibonacciho číslo.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets je řetězec obsahující "<" a ">".
    Vrátí True, pokud všechny otevírací závorky mají odpovídající uzavírací závorky.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """
    Závorky je řetězec obsahující "<" and ">".
    Vrátí True, pokud každá otevírací závorka má odpovídající uzavírací závorku.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """

def correct_bracketing(brackets: str):
    """ šipkové závorky jsou řetězec "<" a "">>".
    return True, pokud má každá otevírací závorka odpovídající uzavírací závorku.

    >>> correct_bracketing("<")
    False
    >>> correct_bracketing("<>")
    True
    >>> correct_bracketing("<<><>>")
    True
    >>> correct_bracketing("><<>")
    False
    """


def monotonic(l: list):
    """Vrátí True, pokud jsou prvky v seznamu monotónně rostoucí nebo klesající.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Vrátí True, pokud prvky seznamu monotónně rostou nebo klesají.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Vrátí True, pokud jsou prvky v seznamu monotónní rostoucí nebo klesající.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Vrátí seřazené jedinečné společné prvky pro dva seznamy.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Vrátí jedinečné společné prvky dvou seznamů, které jsou seřazené.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Vrátí největší prvočíselný dělitel n. Předpokládejme, že n > 1 a není prvočíslo.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Vraťte největší prvočinitel n. Předpokládejme, že n > 1 a není prvočíslo.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    ""Vrátí největší prvočíselný dělitel n. Předpokládejme, že n > 1 a není prvočíslo.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n je funkce, která sčítá čísla od 1 do n.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """ brackets je řetězec obsahující "(" a ")".
    Pokud všechny otevírací závorky mají odpovídající uzavírací závorky, vrátí True.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """

def correct_bracketing(brackets: str):
    """ závorky je řetězec "(" a ")".
    return True, pokud má každá otevírací závorka odpovídající uzavírací závorku.

    >>> correct_bracketing("(")
    False
    >>> correct_bracketing("()")
    True
    >>> correct_bracketing("(()())")
    True
    >>> correct_bracketing(")(()")
    False
    """


def derivative(xs: list):
    """ xs představují koeficienty polynomu.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Vraťte derivaci tohoto polynomu ve stejném tvaru.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs představuje koeficienty polynomu.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    Vrátí derivaci tohoto polynomu ve stejném formátu.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """Sekvence FibFib je podobná Fibonacciho sekvenci a je definována následovně:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Napište funkci pro efektivní výpočet n-tého prvku sekvence FibFib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib číselná sekvence je sekvence podobná Fibbonacciho sekvenci, která je definována takto:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Napište prosím funkci pro efektivní výpočet n-tého prvku fibfib číselné řady.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """Číselná řada FibFib je sekvence podobná Fibbonacciho sekvenci, která je definována následovně:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Napište prosím funkci pro efektivní výpočet n-tého prvku číselné řady FibFib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Přidejte více testovacích případů.
"""

def vowels_count(s):
    """Napište funkci vowels_count, která přijímá řetězec jako vstup a vrací počet
    samohlásek v řetězci. V tomto případě jsou samohlásky 'a', 'e', 'i', 'o', 'u'.
    Zde je 'y' považováno za samohlásku pouze tehdy, když je na konci daného slova.

    Příklad:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Přidejte další testovací případy.
"""

def vowels_count(s):
    """Napište funkci vowels_count, která vezme řetězec představující
    slovo jako vstup a vrátí počet samohlásek v řetězci.
    Samohlásky jsou v tomto případě 'a', 'e', 'i', 'o', 'u'. Zde je „y“ také a
    samohláska, ale jen když je na konci daného slova.

    Příklad:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Přidejte další testovací případy.
"""

def vowels_count(s):
    """Napište funkci, vowels_count které přebírá řetězec reprezentující
    slovo jako vstup a vrací počet samohlásek v řetězci.
    Samohlásky jsou v tomto případě 'a', 'e', 'i', 'o', 'u'. Zde je 'y' také
    samohlásku, ale pouze pokud je na konci daného slova.

    Příklad:
    >>> vowels_count("abcde")
    2
    >>> vowels_count ("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Kruhové posunutí číslic celého čísla x, posunutí číslic doprava po posuvu
    a vrátí výsledek jako řetězec.
    Pokud je posun větší než počet číslic, vrátí číslice obrácené.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Posun kruhově číslice celého čísla x doprava o množství určené parametrem shift
    a vrátí výsledek jako řetězec.
    Pokud je shift větší než počet číslic, otočí číslice a vrátí.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Kruhový posun číslic celého čísla x, posun číslic doprava posunem
    a vrátí výsledek jako řetězec.
    Pokud posunete > počet číslic, vrátí číslice obráceně.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Úkol
    Napište funkci, která přijímá vstup jako řetězec a vrací součet ASCII kódů velkých písmen.

    Příklady:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Úkol
    Napište funkci, která vezme řetězec jako vstup a vrátí součet pouze velkých písmen
    ASCII kódů.

    Příklady:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Úkol
    Napište funkci, která přijímá vstup jako řetězec a vrací součet ASCII kódů velkých písmen.

    Příklad:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    V tomto úkolu dostanete řetězec, který představuje počet jablek a pomerančů
    distribuovaných v košíku s ovocem, který obsahuje jablka, pomeranče a mango.
    Z daného řetězce, který představuje celkový počet pomerančů a jablek, a celého čísla,
    které představuje celkový počet plodů v košíku, vraťte počet plodů mangy v košíku.
    Příklad:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    V tomto úkolu je vám poskytnut řetězec, který udává počet jablek a pomerančů rozdělených v koši s ovocem.
    Tento koš obsahuje jablka, pomeranče a mango.
    Když je vám poskytnut řetězec udávající celkový počet pomerančů a jablek a celé číslo udávající celkový počet ovoce v koši,
    vraťte počet mang v koši.
    Příklad:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    V tomto úkolu dostanete řetězec, který představuje počet jablek a pomerančů
    které jsou v košíku s ovocem obsahujícím jablka, pomeranče a mango
    řetězec, který představuje celkový počet
    pomeranče a jablka a celé číslo, které představuje celkový počet plodů
    v košíku vrátíte počet mango v košíku.
    například:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Dané pole představující větev stromu, která má nezáporné celočíselné uzly
    vaším úkolem je utrhnout jeden z uzlů a vrátit jej.
    Vytržený uzel by měl být uzel s nejmenší sudou hodnotou.
    Pokud je nalezeno více uzlů se stejnou nejmenší sudou hodnotou, vrátí uzel, který má nejmenší index.

    Vytrhnutý uzel by měl být vrácen v seznamu [ nejmenší_hodnota, jeho index ],
    Pokud nejsou žádné sudé hodnoty nebo je dané pole prázdné, vraťte [].

    Příklad 1:
        Vstup: [4,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 má nejmenší sudou hodnotu a 2 má nejmenší index.

    Příklad 2:
        Vstup: [1,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 má nejmenší sudou hodnotu a 2 má nejmenší index.

    Příklad 3:
        Vstup: []
        Výstup: []

    Příklad 4:
        Vstup: [5, 0, 3, 0, 4, 2]
        Výstup: [0, 1]
        Vysvětlení: 0 je nejmenší hodnota, ale jsou zde dvě nuly,
                     vybereme tedy první nulu, která má nejmenší index.

    Omezení:
          * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Pole představuje větev stromu, která je dána, toto pole obsahuje uzly jako nezáporná celá čísla.
    Vaším úkolem je vybrat a vrátit jeden z uzlů.
    Vybraný uzel musí být uzel s nejmenší sudou hodnotou.
    Pokud existuje více uzlů se stejnou nejmenší sudou hodnotou, vraťte uzel s nejmenším indexem.

    Vybraný uzel musí být vrácen jako seznam [nejmenší hodnota, index této hodnoty].
    Pokud neexistuje žádná sudá hodnota nebo je dané pole prázdné, vraťte prázdný seznam.

    Příklad 1:
        Vstup: [4,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 je nejmenší sudá hodnota a 2 má nejmenší index.

    Příklad 2:
        Vstup: [1,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 je nejmenší sudá hodnota a 2 má nejmenší index.

    Příklad 3:
        Vstup: []
        Výstup: []

    Příklad 4:
        Vstup: [5, 0, 3, 0, 4, 2]
        Výstup: [0, 1]
        Vysvětlení: 0 je nejmenší hodnota, ale jsou dvě čísla 0,
                     takže vyberte první 0. To je nejmenší index.

    Omezení:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Je dáno pole představující větev stromu, která má nezáporné celočíselné uzly
    Vaším úkolem je vytrhnout jeden z uzlů a vrátit jej zpět.
    Vytrhnutý uzel by měl být uzel s nejmenší sudou hodnotou.
    Pokud je nalezeno více uzlů se stejnou nejmenší sudou hodnotou, vrátí se uzel, který má nejmenší index.

    Vytrhnutý uzel by měl být vrácen v seznamu, [ smalest_value, jeho index ].
    Pokud neexistují žádné sudé hodnoty nebo je dané pole prázdné, vrátí [].

    Příklad 1:
        Vstup: [4,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 má nejmenší sudou hodnotu a 2 má nejmenší index.

    Příklad 2:
        Vstup: [1,2,3]
        Výstup: [2, 1]
        Vysvětlení: 2 má nejmenší sudou hodnotu a 2 má nejmenší index.

    Příklad 3:
        Vstup: []
        Výstup: []

    Příklad 4:
        Vstup: [5, 0, 3, 0, 4, 2]
        Výstup: [0, 1]
        Vysvětlení: 0 je nejmenší hodnota, ale jsou tam dvě nuly,
                     Vybereme tedy první nulu, která má nejmenší index.

    Omezení:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Je dána neprázdná seznam kladných celých čísel. Vrátí největší celé číslo, které je větší než 0 a jeho četnost je větší nebo rovna jeho vlastní hodnotě.
    Četnost celého čísla je počet jeho výskytů v seznamu.
    Pokud taková hodnota neexistuje, vrátí -1.
    Příklad:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Zobrazí se neprázdný seznam kladných celých čísel. Vraťte největší celé číslo, které je větší než
    nula a má frekvenci větší nebo rovnou hodnotě samotného celého čísla.
    Frekvence celého čísla je počet, kolikrát se objeví v seznamu.
    Pokud žádná taková hodnota neexistuje, vrátí -1.
    Příklady:
     search([4, 1, 2, 2, 3, 1]) == 2
     search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
     search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Pokud je zadán seznam celých čísel, vrátí seznam v podivném pořadí.
    Podivné třídění začíná s nejmenší hodnotou, poté následuje největší hodnota ze zbývajících čísel,
    dále nejmenší hodnota, a tak dále.

    Příklad:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Daný seznam celých čísel, vrátí seznam v podivném pořadí.
    Podivné řazení je, když začnete s minimální hodnotou,
    pak maximum ze zbývajících celých čísel, pak minimum a tak dále.

    Příklady:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Daný seznam celých čísel, seznam seřazený v podivném pořadí.
    Podivné třídění je, když začínáte s minimální hodnotou,
    pak maximum ze zbývajících celých čísel, pak minimum a tak dále.

    Příklady:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Dané délky tří stran trojúhelníku. Vraťte obsah
    trojúhelníku zaokrouhlený na 2 desetinná místa, pokud tři strany tvoří platný trojúhelník.
    Jinak vrátí -1.
    Tři strany tvoří platný trojúhelník, když je součet libovolných dvou stran větší
    než třetí strana.
    Příklad:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Dány délky tří stran trojúhelníku. Vraťte plochu
    zaokrouhlenou na 2 desetinná místa, pokud tyto tři strany tvoří platný trojúhelník.
    V opačném případě vrátí -1
    Tři strany tvoří platný trojúhelník, když součet libovolných dvou stran je větší než
    než třetí strana.
    Příklad:
    triangle_area(3, 4, 5) == 6,00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Když jsou dány délky tří stran trojúhelníku, pokud tyto tři strany tvoří platný trojúhelník,
    vrátí plochu trojúhelníku zaokrouhlenou na dvě desetinná místa.
    Pokud ne, vrátí -1.
    Aby tři strany tvořily platný trojúhelník, součet dvou stran musí být větší než třetí strana.
    Příklad:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Napište funkci, která vrátí True, pokud objekt q poletí, a False jinak.
    Objekt q poletí, pokud je vyvážený (jedná se o palindromický seznam) a součet jeho prvků je menší nebo roven maximální možné hmotnosti w.

    Příklad:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 je menší než maximální možná hmotnost, ale je nevyvážená.

    will_it_fly([3, 2, 3], 1) ➞ False
    # je to vyvážené, ale 3+2+3 je víc než maximální možná váha.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 je menší než maximální možná hmotnost a je vyvážená.

    will_it_fly([3], 5) ➞ True
    # 3 je menší než maximální možná hmotnost a je vyvážená.
    '''

def will_it_fly(q,w):
    '''
    Funkce, která vrací True, pokud objekt q může létat, jinak vrací False.
    Objekt q může létat, pokud je vyvážený (palindromní seznam) a součet jeho prvků je menší nebo roven maximální možné hmotnosti w.

    Příklad:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 je menší než maximální možná hmotnost, ale není vyvážený.

    will_it_fly([3, 2, 3], 1) ➞ False
    # Je vyvážený, ale 3+2+3 je větší než maximální možná hmotnost.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 je menší než maximální možná hmotnost a je vyvážený.

    will_it_fly([3], 5) ➞ True
    # 3 je menší než maximální možná hmotnost a je vyvážený.
    '''

def will_it_fly(q,w):
    '''
    Napište funkci, která vrátí hodnotu True, pokud objekt q poletí, a hodnotu False v opačném případě.
    Objekt q bude létat, pokud je vyvážený (je to palindromický seznam) a součet jeho prvků je menší nebo roven maximální možné váze w.

    Příklad:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 je menší než maximální možná hmotnost, ale je nevyvážená.

    will_it_fly([3, 2, 3], 1) ➞ False
    # je to vyvážené, ale 3+2+3 je více než maximální možná váha.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 je menší než maximální možná hmotnost a je vyvážená.

    will_it_fly([3], 5) ➞ True
    # 3 je menší než maximální možná hmotnost a je vyvážená.
    '''


def smallest_change(arr):
    """
    Vzhledem k poli arr celých čísel najděte minimální počet prvků, které
    je třeba změnit, aby bylo pole palindromické. Palindromické pole je pole, které
    se čte stejně dozadu i dopředu. Při jedné změně můžete změnit jeden prvek na jakýkoli jiný prvek.

    Například:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Pro dané pole celých čísel arr, najděte minimální počet prvků, které je třeba změnit,
    aby se pole stalo symetrickým. Symetrické pole je takové, které je stejné při čtení
    zleva doprava i zprava doleva. Při jedné změně lze změnit jeden prvek na jiný.

    Příklad:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Napište funkci, která přijímá dva seznamy řetězců a vrací seznam, který má
    celkový počet znaků ve všech řetězcích seznamu menší než v druhém seznamu.

    pokud mají oba seznamy stejný počet znaků, vraťte první seznam.

    Příklady
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Napište funkci, která přijímá dva seznamy řetězců a vrací seznam, který má
    Celkový počet znaků ve všech řetězcích seznamu menší než v druhém seznamu.

    Pokud mají dva seznamy stejný počet znaků, vrátí první seznam.

    Příklad
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Přijměte dva seznamy řetězců a napište funkci, která vrátí seznam s celkovým počtem znaků
    všech řetězců menším než druhý seznam.

    Pokud mají oba seznamy stejný počet znaků, vraťte první seznam.

    Příklad
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Napište funkci, která vrátí true, pokud je dané číslo součinem 3 prvočísel,
    jinak vrátí false.
    Víme, že (a) je menší než 100.
    Příklad:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Napište funkci, která vrátí hodnotu True, pokud je dané číslo součinem 3 prvočísel
    a jinak False.
    Vědět, že (a) je menší než 100.
    Příklad:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Napište funkci, která vrátí hodnotu true, pokud je dané číslo součinem 3 prvočísel
    a jinak false.
    Vědět, že (a) je menší než 100.
    Příklad:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Vaším úkolem je napsat funkci, která vrátí true, pokud je číslo x jednoduchou mocninou n,
    a false, pokud není.
    x je jednoduchou mocninou n, když n**int=x.
    Příklad:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Vaším úkolem je napsat funkci, která vrátí hodnotu true, pokud je číslo x jednoduché
    mocnina n a nepravda v ostatních případech.
    x je jednoduchá mocnina n, jestliže n**int=x
    Například:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """

def is_simple_power(x, n):
    """Vaším úkolem je napsat funkci, která vrátí hodnotu true, pokud je číslo x celočíselná
    mocnina n a nepravda v ostatních případech.
    x je jednoduchá mocnina n, jestliže n**int=x
    Například:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Napište funkci, která vezme celé číslo a a vrátí True
    pokud je tento ingeger krychlí nějakého celého čísla.
    Poznámka: Můžete předpokládat, že zadání je vždy platné.
    Příklady:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Zadejte celé číslo a a napište funkci, která vrátí, zda je toto celé číslo třetí mocninou nějakého celého čísla.
    Odkaz: Lze předpokládat, že vstup je vždy platný.
    Příklad:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """Napište funkci pro spočítání počtu prvočísel v šestnáctkových číslicích
    zadaných jako řetězec.
    (Prvočíslo je přirozené číslo větší než 1, které není součinem dvou menších přirozených čísel).
    Šestnáctkové číslice jsou 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Prvočísla jsou 2, 3, 5, 7, 11, 13, 17,...
    Proto je třeba určit počet následujících čísel: 2, 3, 5, 7,
    B (=11 v desítkové soustavě), D (=13 v desítkové soustavě).
    Poznámka: Můžete předpokládat, že vstup je vždy platný nebo prázdný řetězec,
    a že znaky A, B, C, D, E, F jsou vždy velká písmena.
    Příklad:
    Když num = "AB", výstup musí být 1.
    Když num = "1077E", výstup musí být 2.
    Když num = "ABED1A33", výstup musí být 4.
    Když num = "123456789ABCDEF0", výstup musí být 6.
    Když num = "2020", výstup musí být 2.
    """

def hex_key(číslo):
    """Dostali jste za úkol napsat funkci, která přijímá
    hexadecimální číslo jako řetězec a spočítá počet hexadecimálních
    číslice, které jsou prvočísly (Prvočíslo, neboli prvočíslo, je přirozené číslo
    větší než 1, která není součinem dvou menších přirozených čísel).
    Hexadecimální číslice jsou 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Prvočísla jsou 2, 3, 5, 7, 11, 13, 17,...
    Musíte tedy určit počet následujících číslic: 2, 3, 5, 7,
    B (=11 v desítkové soustavě), D (=13 v desítkové soustavě).
    Poznámka: můžete předpokládat, že vstup je vždy správný nebo prázdný řetězec,
    a symboly A, B, C, D, E, F jsou vždy velkými písmeny.
    Příklady:
    Pro num = "AB" by výstup měl být 1.
    Pro num = "1077E" by výstup měl být 2.
    Pro num = "ABED1A33" by výstup měl být 4.
    Pro num = "123456789ABCDEF0" by výstup měl být 6.
    Pro num = "2020" by výstup měl být 2.
    """

def hex_key(num):
    """Dostali jste za úkol napsat funkci, která přijímá
    hexadecimální číslo jako řetězec a počítá hexadecimální
    číslice, které jsou prvočísla (prvočíslo nebo prvočíslo je přirozené číslo
    větší než 1, které není součinem dvou menších přirozených čísel).
    Hexadecimální číslice jsou 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Prvočísla jsou 2, 3, 5, 7, 11, 13, 17,...
    Musíte tedy určit počet následujících číslic: 2, 3, 5, 7,
    B (=desetinné 11), D (=desetinné 13).
    Poznámka: můžete předpokládat, že vstup je vždy správný nebo prázdný řetězec,
    a symboly A,B,C,D,E,F jsou vždy velká.
    Příklady:
    For num = "AB" the output should be 1.
    For num = "1077E" the output should be 2.
    For num = "ABED1A33" the output should be 4.
    For num = "123456789ABCDEF0" the output should be 6.
    For num = "2020" the output should be 2.
    """


def decimal_to_binary(decimal):
    """Číslo ve v desítkové formě je poskytnuto a úkolem je převést toto číslo do binární formě.
    Funkce by měla vrátit řetězec, ve kterém každý znak představuje binární číslice.
    Každý znak v řetězci bude '0' nebo '1'.

    Na začátku a na konci řetězce jsou přidány znaky 'db'.
    Tyto přidané znaky existují pro podporu formátování.

    Příklad:
    decimal_to_binary(15)   # Vrátí "db1111db"
    decimal_to_binary(32)   # Vrátí "db100000db"
    """

def decimal_to_binary(decimal):
    """Dostanete číslo v desítkovém tvaru a vaším úkolem je převést ho na
    binární formát. Funkce by měla vrátit řetězec, přičemž každý znak představuje binární číslo
    číslo. Každý znak v řetězci bude '0' nebo '1'.

    Na začátku a na konci řetězce budou dva další znaky 'db'.
    Tyto znaky jsou tu, aby pomohly s formátováním.

    Příklady:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Dostanete číslo v desítkovém tvaru a vaším úkolem je převést ho na
    binární formát. Funkce by měla vrátit řetězec, přičemž každý znak představuje binární kód
    číslo. Každý znak v řetězci bude '0' nebo '1'.

    Na začátku a na konci řetězce bude několik dalších znaků 'db'.
    Znaky navíc jsou tu, aby pomohly s formátováním.

    Příklady:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """Je vám dán řetězec s.
    Vaším úkolem je zkontrolovat, zda je řetězec šťastný nebo ne.
    Řetězec je šťastný, pokud je jeho délka alespoň 3 a každé 3 po sobě jdoucí písmena jsou odlišná
    Například:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Dostanete řetězec s.
    Vaším úkolem je zkontrolovat, zda je řetězec šťastný nebo ne.
    Řetězec je šťastný, pokud je jeho délka alespoň 3 a každé 3 po sobě jdoucí písmena jsou odlišná
    Například:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Řetězec s je dán.
    Úkolem je zjistit, zda je řetězec šťastný.
    Aby byl řetězec považován za šťastný, jeho délka musí být alespoň 3 a 3 po sobě jdoucí znaky musí být různé.
    Příklad:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """Je poslední týden semestru a učitelka musí studentům dát známky.
    Učitelka si vytvořila vlastní algoritmus pro hodnocení.
    Jediným problémem je, že ztratila kód, který používala pro hodnocení.
    Dala vám seznam GPA některých studentů a vy musíte napsat funkci,
    která vrátí seznam písmených známek podle následující tabulky:
             GPA       |    Písmenná známka
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Příklad:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Je poslední týden semestru a učitel musí dát známky
    studentům. učitel vytvořila svůj vlastní algoritmus pro známkování.
    Jediný problém je, že ztratila kód, který používala pro hodnocení.
    Dala vám seznam GPA pro některé studenty a vy musíte napsat
    funkce, která dokáže vytvořit seznam písmenných známek pomocí následující tabulky:
             GPA |    písmenná známka
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Příklad:
    numerical_letter_grade([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Poslední týden semestru a učitel potřebuje ohodnotit studenty.
    Učitel vytváří svůj vlastní algoritmus pro hodnocení.
    Problém je, že ztratil kód, který používal pro hodnocení.
    Poskytl seznam GPA některých studentů a vy potřebujete napsat
    funkci, která může vrátit seznam známek pomocí následující tabulky:
             GPA       |    Známka
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

    Příklad:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Napište funkci, která vezme řetězec a vrátí hodnotu True, pokud je délka řetězce prvočíslem, jinak vrátí False
    Příklady
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Napište funkci, která vezme řetězec a vrátí True, pokud řetězec
    délka je prvočíslo, jinak False
    Příklady
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Přijme řetězec a vrátí True, pokud je délka řetězce prvočíslo,
    a vrátí False, pokud není.
    Příklad
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Pro dané kladné celé číslo n vraťte počet n-ciferných kladných celých čísel, která začínají nebo končí číslicí 1.
    """

def starts_one_ends(n):
    """
    Pro dané kladné celé číslo n, vraťte počet kladných celých čísel s n číslicemi, které začínají nebo končí číslicí 1.
    """

def starts_one_ends(n):
    """
    Pro dané kladné celé číslo n, vrátí počet n-ciferných čísel
    kladných celých čísel začínajících nebo končících číslicí 1.
    """


def solve(N):
    """Vzhledem k kladnému celému číslu N vrátí celkový součet jeho číslic v binární soustavě.

    Příklad
        Pro N = 1000 bude součet číslic 1, výstup by měl být "1".
        Pro N = 150 bude součet číslic 6, výstup by měl být "110".
        Pro N = 147 bude součet číslic 12, výstup by měl být "1100".

    Proměnné:
        @N celé číslo
             Omezení: 0 ≤ N ≤ 10000.
    Výstup:
         řetězec binárního čísla
    """

def solve(N):
    """Když je dáno kladné celé číslo N, vraťte součet číslic ve dvojkové soustavě.

    Příklad
        Když N = 1000, součet číslic je 1 a výstup by měl být "1".
        Když N = 150, součet číslic je 6 a výstup by měl být "110".
        Když N = 147, součet číslic je 12 a výstup by měl být "1100".

    Proměnná:
        @N celé číslo
             Podmínka: 0 ≤ N ≤ 10000.
    Výstup:
         Binární řetězec
    """

def solve(N):
    """Vzhledem k kladnému celému číslu N vraťte celkový součet jeho číslic v binární podobě.

    Příklad
        Pro N = 1000 bude součet číslic 1, výstup by měl být "1".
        Pro N = 150 bude součet číslic 6, výstup by měl být "110".
        Pro N = 147 bude součet číslic 12, výstup by měl být "1100".

    Proměnné:
        @N integer
             Omezení: 0 ≤ N ≤ 10000.
    výstup:
         řetězec binárního čísla
    """


def add(lst):
    """
    Když je dáno neprázdné pole čísel lst obsahující celá čísla,
    sečtěte sudé prvky na lichých indexech.

    Příklad:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Daný neprázdný seznam celých čísel lst. přidejte sudé prvky, které jsou na lichých indexech..

    Příklady:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Zadaný seznam celých čísel není prázdný, přidejte sudé prvky, které se nacházejí na lichých indexech.

    Examples:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Přijme řetězec a vrátí jeho seřazenou verzi.
    Seřazená verze řetězce je řetězec, kde všechna slova (oddělená mezerami)
    jsou nahrazena znaky seřazenými vzestupně podle hodnoty ASCII.
    Poznámka: Pořadí slov a mezer ve větě musí zůstat zachováno.

    Příklad:
    anti_shuffle('Hi') vrátí 'Hi'.
    anti_shuffle('hello') vrátí 'ehllo'.
    anti_shuffle('Hello World!!!') vrátí 'Hello !!!Wdlor'.
    """

def anti_shuffle(s):
    """
    Napište funkci, která převezme řetězec a vrátí jeho uspořádanou verzi.
    Uspořádaná verze slova string, je řetězec, ve kterém jsou všechna slova (oddělená mezerou)
    nahrazeny novým slovem, kde jsou všechny znaky uspořádané v
    Vzestupné pořadí na základě hodnoty ASCII.
    Poznámka: Měli byste zachovat pořadí slov a mezer ve větě.

    Například:
    anti_shuffle('Hi') vrátí 'Hi'
    anti_shuffle('hello') vrátí 'ehllo'
    anti_shuffle('Hello World!!!') vrátí 'Hello !!! Wdlor'
    """

def anti_shuffle(s):
    """
    Napište funkci, která vezme řetězec a vrátí jeho uspořádanou verzi.
    Uspořádaná verze řetězce, je řetězec, ve kterém jsou všechna slova (oddělená mezerou)
    jsou nahrazeny novým slovem, kde jsou uspořádány všechny znaky
    vzestupně na základě hodnoty ascii.
    Poznámka: Měli byste dodržet pořadí slov a mezer ve větě.

    Například:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Dostanete 2-rozměrná data ve formě vnořených seznamů,
    která jsou podobná matici, ale na rozdíl od matic,
    každý řádek může obsahovat jiný počet sloupců.
    Zadané lst a celé číslo x, najděte všechny výskyty čísla x v seznamu,
    a vraťte seznam dvojic, [(x1, y1), (x2, y2) ...], kde
    každá dvojice je souřadnice - (řádek, sloupec), počínaje indexem 0.
    Seřaďte nejprve souřadnice podle řádků ve vzestupném pořadí.
    Seřaďte také souřadnice v rámci jednotlivých řádků podle sloupců v sestupném pořadí.

    Příklady:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Dvourozměrná data jsou poskytována ve formě vnořených seznamů.
    Toto je podobné matici, ale na rozdíl od matice může každý řádek obsahovat různý počet sloupců.
    Když jsou lst a celé číslo x dány, najděte celé číslo x v seznamu
    a vraťte seznam dvojic souřadnic - (řádek, sloupec) [(x1, y1), (x2, y2) ...].
    Souřadnice jsou seřazeny vzestupně podle řádků.
    Navíc, souřadnice řádků jsou seřazeny sestupně podle sloupců.

    Příklad:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    Dostanete 2rozměrná data jako vnořené seznamy,
    která je podobná matici, ale na rozdíl od matic,
    každý řádek může obsahovat jiný počet sloupců.
    Dané lst a celé číslo x najděte celá čísla x v seznamu,
    a vrátí seznam n-tic, [(x1, y1), (x2, y2) ...] tak, že
    každá n-tice je souřadnice - (řádek, sloupec), počínaje 0.
    Nejprve seřaďte souřadnice podle řádků ve vzestupném pořadí.
    Také seřaďte souřadnice řádku podle sloupců v sestupném pořadí.

    Příklady:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Při zadání pole nezáporných celých čísel vraťte kopii tohoto pole, která bude seřazena. Pokud je součet první a poslední hodnoty indexu lichý, seřaďte pole vzestupně. Pokud je součet první a poslední hodnoty indexu sudý, seřaďte ho sestupně.

    Poznámka:
    *Neměňte zadané pole.

    Příklady:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Vzhledem k poli nezáporných celých čísel vraťte po třídění kopii daného pole,
    Pokud je součet (první hodnota indexu, poslední hodnota indexu) lichý, seřadíte dané pole vzestupně,
    nebo jej seřaďte sestupně, pokud je součet (první hodnota indexu, poslední hodnota indexu) sudý.

    Poznámka:
    * neměňte dané pole.

    Příklady:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Je dáno pole nezáporných celých čísel, vrátí kopii pole, které je seřazené.
    Pokud je součet hodnot na prvním a posledním indexu lichý, seřaďte pole vzestupně,
    pokud je součet sudý, seřaďte pole sestupně.

    Poznámka:
    * Neměňte zadané pole.

    Příklad:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """


def encrypt(s):
    """Vytvořte funkci encrypt, která vezme řetězec jako argument a
    vrátí řetězec zašifrovaný s otočenou abecedou.
    Abeceda by měla být otočena tak, že písmena budou posunuta o čtyři místa.
    Například:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """

def encrypt(s):
    """Vytvořte funkci šifrování, která vezme řetězec jako argument a
    vrátí řetězec zašifrovaný s otočenou abecedou.
    Abeceda by měla být otočena tak, aby písmena
    posunuta o čtyři místa dopředu.
    Například:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """

def encrypt(s):
    """Vytvořte funkci encrypt, která vezme řetězec jako argument a
    vrátí řetězec zašifrovaný s otočenou abecedou.
    Abeceda by měla být otočena tak, aby písmena
    posunuta o čtyři pozice dopředu.
    Například:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """


def next_smallest(lst):
    """
    Je vám zadán seznam celých čísel.
    Napište funkci next_smallest(), která vrátí 2. nejmenší prvek seznamu.
    Vrátí None, pokud takový prvek neexistuje.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Dostanete seznam celých čísel.
    Napište funkci next_smallest(), která vrací 2. nejmenší prvek seznamu.
    Vrátí None, pokud žádný takový prvek neexistuje.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """

def next_smallest(lst):
    """
    Je dán seznam celých čísel.
    Napište funkci next_smallest(), která vrátí druhý nejmenší prvek v seznamu.
    Pokud takový prvek neexistuje, vraťte None.

    next_smallest([1, 2, 3, 4, 5]) == 2
    next_smallest([5, 1, 4, 3, 2]) == 2
    next_smallest([]) == None
    next_smallest([1, 1]) == None
    """


def is_bored(S):
    """
    Dostanete řetězec slov a vaším úkolem je spočítat počet případů nudy.
    Nuda je věta, která začíná slovem „já“ (I).
    Věty jsou odděleny '.', '?' nebo '!'.

    Například:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Dostanete řetězec slov a vaším úkolem je spočítat počet
    případů nudy. Nuda je věta, která začíná slovem "I".
    Věty jsou odděleny znaky '.', '?' nebo '!'.

    Například:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Je dán řetězec, vaším úkolem je spočítat počet nudných vět.
    Nudné jsou věty začínající slovem "I".
    Věty jsou odděleny '.', '?' nebo '!'.

    Příklad:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    Vytvořte funkci, která přijímá 3 čísla.
    Vrátí true, pokud jedno z těchto tří čísel je rovno součtu zbývajících dvou čísel a všechna čísla jsou celá čísla.
    Vrátí false v ostatních případech.

    Příklad
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False
    '''

def any_int(x, y, z):
    '''
    Vytvořte funkci, která má 3 čísla.
    Vrátí hodnotu true, pokud se jedno z čísel rovná součtu ostatních dvou a všechna čísla jsou celá čísla.
    V ostatních případech vrací false.

    Příklady
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Vytvořte funkci, která má 3 čísla.
    Vrátí hodnotu true, pokud se jedno z čísel rovná součtu ostatních dvou a všechna čísla jsou celá čísla.
    V ostatních případech vrací false.

    Příklady
    any_int(5, 2, 7) ➞ Pravda

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ Pravda

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Napište funkci, která vezme zprávu a zakóduje ji tak, že prohodí velká a malá písmena u všech písmen, nahradí všechny samohlásky ve zprávě písmenem, které se nachází o 2 místa dál v anglické abecedě.
    Předpokládejme, že ve zprávě jsou pouze písmena.

    Příklady:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Přijme zprávu a změní velká písmena na malá a naopak,
    poté nahradí všechny samohlásky ve zprávě písmenem,
    které stojí o 2 pozice před samohláskou v abecedě.
    Předpokládejme, že jsou pouze znaky abecedy.

    Příklad:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Napište funkci, která vezme zprávu a zakóduje ji
    způsobem, že zamění velká a malá písmena, nahradí všechny samohlásky
    zprávu písmenem, které se objeví 2 místa za danou
    samohláska v anglické abecedě.
    Předpokládejte pouze písmena.

    Příklady:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """
    Zobrazí se seznam celých čísel.
    Musíte najít největší prvočíslo a vrátit součet jeho číslic.

    Příklady:
    Pro lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] by měl být výstup 10.
    Pro lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] by měl být výstup 25.
    Pro lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] by měl být výstup 13.
    Pro lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] by měl být výstup 11.
    Pro lst = [0,81,12,3,1,21] by měl být výstup 3.
    Pro lst = [0,8,1,2,1,7] by měl být výstup 7.
    """

def skjkasdkd(lst):
    """Dostanete seznam celých čísel.
    Musíte najít největší prvočíslo a vrátit součet jejích číslic.

    Příklady:
    Pro lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,3,2,32,324,4,3] by měl být výstup 10
    Pro lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] by měl být výstup 25
    Pro lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] by měl být výstup 13
    Pro lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] by měl být výstup 11
    Pro lst = [0,81,12,3,1,21] by měl být výstup 3
    Pro lst = [0,8,1,2,1,7] by měl být výstup 7
    """

def skjkasdkd(lst):
    """Je dán seznam celých čísel.
    Je třeba najít největší prvočíslo a vrátit součet jeho číslic.

    Příklad:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] pak výstup musí být 10.
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] pak výstup musí být 25.
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] pak výstup musí být 13.
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] pak výstup musí být 11.
    lst = [0,81,12,3,1,21] pak výstup musí být 3.
    lst = [0,8,1,2,1,7] pak výstup musí být 7.
    """


def check_dict_case(dict):
    """
    Vrátí True, pokud všechny klíče ve zadaném slovníku jsou buď všechny malými písmeny, nebo všechny velkými písmeny,
    jinak vrátí False.
    Pokud je zadaný slovník prázdný, funkce musí vrátit False.
    Příklad:
    check_dict_case({"a":"apple", "b":"banana"}) musí vrátit True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) musí vrátit False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) musí vrátit False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) musí vrátit False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) musí vrátit True.
    """

def check_dict_case(dict):
    """
    Pro daný slovník vraťte hodnotu True, pokud jsou všechny klíče řetězce v malých písmech
    nebo všechny klíče jsou řetězce s velkými písmeny, jinak vraťte False.
    Funkce by měla vrátit False, pokud je daný slovník prázdný.

    Příklady:
    check_dict_case({"a":"apple", "b":"banana"}) by měla vrátit True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) by měla vrátit False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) by měla vrátit False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) by měla vrátit False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) by měla vrátit True.
    """

def check_dict_case(dict):
    """
    V případě slovníku vraťte hodnotu True, pokud jsou všechny klíče řetězce v malých písmenech
    nebo všechny klíče jsou řetězce s velkými písmeny, jinak vrátí False.
    Funkce by měla vrátit False, pokud je daný slovník prázdný.
    Příklady:
    check_dict_case({"a":"apple", "b":"banana"}) should return True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
    """


def count_up_to(n):
    """Implementujte funkci, která vezme nezáporné celé číslo a vrátí pole prvního n
    celá čísla, která jsou prvočísla a jsou menší než n.
    například:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Implementujte funkci, která vezme nezáporné celé číslo a vrátí pole prvních n
    Celá čísla, která jsou prvočísla a jsou menší než N.
    například:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Implementace funkce, která bere nezáporné celé číslo a vrátí pole prvního n
        celá čísla, která jsou prvočísla a menší než n.
    Příklad:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """