from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Проверите да ли у датој листи бројева постоје два броја која су ближа један другом од датог прага.
    >>> 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:
    """ Провери да ли у листи постоје два броја која су ближа једна другом од
    датог прага.
    >>> 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]:
    """ Улаз за ову функцију је стринг који садржи више група угнежђених заграда. Ваш циљ је да
    раздвојите те групе у засебне низове и вратите листу тих.
    Одвојене групе су избалансиране (свака отворена заграда је правилно затворена) и нису угнежђене једна у другу
    Занемарите све размаке у улазном низу.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Улаз у ову функцију је стринг који садржи више група угнежђених заграда. Ваш циљ је да
    раздвојите те групе у одвојене стрингове и вратите листу тих стрингова.
    Одвојене групе су уравнотежене (свака отворена заграда је исправно затворена) и нису угнежђене једна у другу
    Игноришите све размаке у улазном стрингу.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ Ова функција прима низ који садржи више угнежђених заграда. Циљ је да се ове групе поделе на посебне низове
    и врати та листа. Свака група је избалансирана (свака отворена заграда је правилно затворена) и нису угнежђене.
    Размаци у улазном стрингу се игноришу.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Ако је дат позитиван децимални број, може се поделити на његов цео део
    (највећи цео број који је мањи од датог броја) и децимални део
    (остатак који је увек мањи од 1).

    Враћа децимални део броја.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Дат позитиван број са покретним зарезом, може се разложити на
    и целобројни део (највећи цео број мањи од датог броја) и децимале
    (остали део увек мањи од 1).

    Врати децимални део броја.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Ако је дат позитиван децимални број, може се поделити на
    цео део (највећи цео број који је мањи од датог броја) и децимални део
    (остатак који је увек мањи од 1).

    Враћа децимални део броја.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Дата је листа операција уплата и исплата на банковном рачуну.
    Стање рачуна почиње од 0.
    Задатак је утврдити када стање падне испод 0,
    и у том случају функција треба да врати True. У супротном враћа 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:
    """ Добијате листу операција депозита и повлачења на банковном рачуну која почиње са
    нулти биланс. Ваш задатак је да откријете да ли у било ком тренутку стање на рачуну падне испод нуле, и
    у том тренутку функција треба да врати Труе. У супротном би требало да врати Фалсе.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Дата вам је листа операција уплата и исплата на банковном рачуну која почиње са
    нултим стањем. Ваш задатак је да детектујете да ли је у било ком тренутку стање рачуна пало испод нуле , и
    и у том случају функција треба да врати True. У супротном враћа 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:
    """ За дату листу улазних бројева, израчунајте средњу апсолутну девијацију
    око средње вредности овог скупа података.
    Средња апсолутна девијација је просечна апсолутна разлика између сваког
    елемента и централне тачке (средња вредност у овом случају):
    MAD = average | 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:
    """ За дату листу улазних бројева, израчунајте средњу вредност Mean Absolute Deviation
    око средње вредности овог скупа података.
    Mean Absolute Deviation је просечна апсолутна разлика између сваког
    елемент и централна тачка (у овом случају значи):
    MAD = average | 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:
    """ За дату листу улазних бројева, израчунајте средњу апсолутну девијацију
    око средње вредности овог скупа података.
    Средња апсолутна девијација је просечна апсолутна разлика између сваког од њих
    елемент и централна тачка (значи у овом случају):
    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]:
    """Уметните број 'delimeter' између свака два узастопна елемента у датој листи `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]:
    """ Убаците број 'делиметар' између свака два узастопна елемента улазне листе `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]:
    """ Убаците број 'delimeter' између свака два узастопна елемента улазне листе `numbers'
    >>> 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]:
    """ Функција прима низ карактера који представља више група угњеждених заграда, одвојених размаком.
    За сваку групу враћа најдубљи ниво угњеждења заграда.
    На пример: (()()) садржи највише два нивоа угњеждења, док ((())) има три нивоа угњеждења.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Улаз за ову функцију је низ који представља више група за угнежђене заграде одвојене размацима.
    За сваку групу испишите најдубљи ниво угнежђења заграда.
    Нпр. (()()) има највише два нивоа угнежђења док ((())) има три.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Функција прима стринг који представља више група угњеждених заграда, одвојених размаком.
    За сваку групу враћа најдубљи ниво угњеждења заграда.
    На пример (()()) садржи највише два нивоа угњеждења, док ((())) има три нивоа угњеждења.

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Филтрирајте улазну листу стрингова само за оне који садрже дати подниз
    >>> 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]:
    """ Филтрирање листе улазних низова карактера тако да остану само они низови који садрже задати подниз.
    >>> 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]:
    """ Враћа пар који садржи збир и производ свих целих бројева у датој листи.
    Збир празне листе је 0, а производ празне листе треба да буде 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]:
    """ За дату листу целих бројева, вратите тупле који се састоји од збира и производа свих целих бројева на листи.
    Празан збир треба да буде једнак 0, а празан производ треба да буде једнак 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]:
    """ За дати низ integer-а, вратите tuple који се састоји од збира и производа свих  integer-а у том низу.
    Ако је низ празан, збир треба бити 0, а производ треба да буде 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]:
    """ Из дате листе целих бројева, генеришите листу покретних максималних елемената пронађених до датог тренутка
    у низу.
    >>> 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]:
    """ Из дате листе целих бројева, генеришите листу са максималним елементом који је пронађен до датог тренутка
    у низу.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Тестирај да ли је дати низ палиндром """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Пронађи најкраћи палиндром који почиње датим низом.
    Идеја алгоритма је једноставна:
    - Пронађи најдужи суфикс датог низа који је палиндром.
    - Додај на крај низа обрнуто од префикса низа који долази пре палиндромског суфикса.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Тестира да ли је задати низ палиндром """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Пронађите најкраћи палиндром који почиње датим низом.
    Идеја алгоритма је веома једноставна:
    - Пронађите најдужи суфикс датог низа који је палиндром.
    - Додајте обрнути префикс низа испред палиндромског суфикса на крају низа.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Проверите да ли је дати низ палиндром """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Пронађите најкраћи палиндром који почиње датим низом.
    Идеја алгоритма је веома једноставна:
    - Пронађите најдужи суфикс датог низа који је палиндром.
    - Додајте обрнути префикс низа испред палиндромског суфикса на крају низа.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """ Улаз су два низа a и b који се састоје само од 1s и 0s.
    Изврши бинарно XOR на овим улазима и враћају резултат такође као низ.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Улаз су два низа а и б који се састоје само од 1 и 0.
    Извршите бинарни КСОР на овим улазима и вратите резултат такође као стринг.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ Два улазна стринга, a и b, који садрже само 1 и 0.
    Извршите бинарну XOR операцију над овим улазима и вратите резултат као стринг.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Са листе низова, врати најдужи. Вратите први у случају више
    низова исте дужине. Вратите None у случају да је улазна листа празна.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Из листе string-ова, вратите најдужи. Вратите први у случају више string-ова исте дужине.
    Вратите None у случају да је улазна листа празна.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Од листе низова, врати најдужи низ. Ако постоји више низова исте дужине,
    врати први низ. Ако је улазна листа празна, врати None.
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ Враћа највећи заједнички делилац два цела броја a и b.
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Врати највећи заједнички делилац два цела броја, a и b
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Враћа највећи заједнички делилац два цела броја, 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]:
    """ Од датог низа карактера, врати листу свих префикса од најкраћег до најдужег.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Врати листу свих префикса од најкраћег до најдужег улазног низа
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Враћа листу свих префиска од најкраћег до најдужег од датог string-а
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Враћа низ карактера који садржи бројеве од 0 до n (укључујући оба), одвојене размаком.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Врати низ који садржи бројеве раздвојене размаком почевши од 0 до n укључујући.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Врати низ који садржи бројеве раздвојене размаком почевши од 0 до н укључујући.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Одреди колико различитих карактера (без разликовања малих и великих слова) има у датом низу
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ За дат стринг, пронађите колико различитих карактера садржи (без обзира на велика и мала слова)
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """ Дати низ, сазнајте од колико различитих знакова (без обзира на велика и мала слова) се састоји
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Ова функција прихвата улазни низ који представља ноте у специјалном ASCII формату.
    Задатак је да анализира овај низ и врати листу целих бројева која представља колико тактова траје свака нота.

    Легенда је следећа:
    'o' - цела нота, траје 4 такта
    'o|' - половина ноте, траје 2 такта
    '.|' - четвртина ноте, траје 1 такт

    >>> 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]:
    """ Улаз у ову функцију је стринг који представља музичке ноте у посебном ASCII формату.
    Ваш задатак је да анализирате овај стринг и вратите листу целих бројева која представља колико такова свака нота
    траје.

    Легенда је следећа:
    'o' - цела нота, траје 4 такта
    'o|' - половина ноте, траје 2 такта
    '.|' - четвртина ноте, траје 1 такт

    >>> 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]:
    """ Улазни податак у ову функцију је string који представља музичке ноте у специјалном ASCII формату.
    Твој задатак је да  рашчланиш овај string и вратиш листу integer-а која одговара томе
    колико тактова траје свака нота.

    Ево легенде:
    'o' - цела нота, траје четири откуцаја
    'o|' - половина ноте, траје два откуцаја
    '.|' - четвртина ноте, траје један откуцај

    >>> 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:
    """ Пронађите колико пута се задати подстринг може наћи у оригиналном стрингу. Бројите случајеве преклапања.
    >>> 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:
    """ Одреди колико пута се дати подниз карактера налази у оригиналном низу. Броји случајеве преклапања.
    >>> 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:
    """ Пронађите колико пута се дати подстринг може наћи у оригиналном низу. Бројите случајеве који се преклапају.
    >>> 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:
    """ Улаз је низ карактера који садржи бројеве од 'zero' до 'nine', раздвојене размаком.
    Важеће опције: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'.
    Враћа низ који садржи бројеве у растућем редоследу.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Улаз је стринг који садржи бројеве од 'zero' до 'nine', раздвојене размаком.
    Важеће опције: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'.
    Враћа стринг који садржи бројеве у растућем редоследу.
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ Input is a space-delimited string of numberals from 'zero' to 'nine'.
    Улаз је стринг који садржи бројеве од 'zero' до 'nine', раздвојене размаком.
    Важеће опције су: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' и 'nine'.
    Враћа стринг са бројевима сортираним од најмањег до највећег
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Изаберите два најближа броја из дате листе бројева (дужине најмање два елемента)
    и вратите их у редоследу мањи број, већи број.
    >>> 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]:
    """ Из дате листе бројева (дужине најмање два елемента) изаберите и вратите два која су најближа један
    другом и вратите их у редоследу (мањи број, већи број).
    >>> 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]:
    """ Са достављене листе бројева (дужине најмање два) изаберите и вратите два која су најближа сваком
    други и врати их по реду (мањи број, већи број).
    >>> 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]:
    """ Ако је дата листа бројева која садржи најмање два елемента,
    користите линеарну трансформацију тако да најмањи број буде 0,
    а највећи број буде 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]:
    """ Ако је дата листа бројева (са најмање два елемента), примените линеарну трансформацију на ту листу,
    тако да најмањи број постане 0, а највећи постане 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]:
    """ Дата листа бројева (са најмање два елемента), применити линерану трансформацију на ту листу,
    тако да најмањи број постане 0, а највећи постане 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]:
    """ Филтрирајте дату листу било које python вредности само за целе бројеве
    >>> 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]:
    """ Филтрирај само целе броје из дате листе било којих python вредности
    >>> 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]:
    """ Филтрирајте дату листу било које Питхон вредности само за целе бројеве
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Враћа дужину задатог низа карактера
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Повратна дужина датог низа
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Пронађи највећи број мањи од n, којим је n дељив.
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ За дати број н пронаћи највећи број који дели н једнако, мањи од n
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ За дати број n, пронађи највећи број који дели n једнако, мањи од n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Враћа листу простих фактора датог целог броја у редоследу од најмањег ка највећем.
    Сваки фактор треба навести онолико пута колико се појављује у разлагању.
    Улазни број мора бити једнак производу свих фактора.
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Врати листу простих фактора датог целог броја по редоследу од најмањег до највећег.
    Сваки од фактора треба да буде наведен број пута који одговара колико пута се појављује у факторизацији.
    Улазни број треба да буде једнак производу свих фактора
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Уклања све елементе који се у листи целих бројева појављују више од једном.
    Чува редослед преосталих елемената према улазу.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Са листе целих бројева, уклоните све елементе који се јављају више пута.
    Задржите редослед остављених елемената исти као у уносу.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Из листе целих бројева, уклоните све елементе који се појављују више од једном.
    Задржите исти редослед елемената као у улазу.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ За дати низ, окрените мала слова на велика и велика на мала слова.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ За дати низ, претвори мала слова у велика и велика слова у мала.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ За дати стринг, претвори мала слова у велика и велика слова у мала.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ Спојите листу стрингова у један стринг
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Спаја листу низова карактера у један низ
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ Филтрирајте листу улазних низова тако да остану само низови који почињу са датим префиксом.
    >>> 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]:
    """ Филтрирајте улазну листу стрингова само за оне који почињу са датим префиксом.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Враћа само позитивне бројеве из листе.
    >>> 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):
    """Врати тачно ако је дати број прост, и нетачно у супротном.
    >>> 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):
    """Враћа true ако је дати број прост, иначе враћа 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):
    """
    Израчунава полином са коефицијентима xs у тачки x.
    враћа 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 су коефицијенти полинома.
    find_zero проналази x за који је poly(x) = 0.
    find_zero враћа само једну тачку нуле, чак и ако их има више.
    Поред тога, find_zero прихвата само листу xs са парним бројем коефицијената
    и са највећим ненултим коефицијентом, јер то гарантује
    решење.
    >>> 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):
    """
    Полином xs коефицијенти се процењују у тачки 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 су коефицијенти полинома.
    find_zero тражи x за који је poly(x) = 0.
    find_zero враћа само једно решење, чак и ако постоји више решења.
    Поред тога, find_zero прихвата само xs листу са парним бројем коефицијената
    и највећим ненултим коефицијентом јер ово гарантује решење.
    >>> 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):
    """
    Оцени полином са коефицијентима xs у тачки 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 су коефицијенти полинома.
    find_zero пронађи x тако да је poly(x) = 0.
    find_zero враћа само нулту тачку, иако их има много.
    Штавише, find_zero узима само листу xs која има паран број коефицијената
    и највећи коефицијент који није нула будући да он гарантује
    решење.
    >>> 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):
    """Ова функција узима листу l и враћа листу l' такав да
    l' је идентично са l у индексима који нису дељиви са три, док су његове вредности код индекса који су дељиви са три једнаке
    на вредности одговарајућих индекса од l, али сортирано.
    >>> 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: list):
    """Ова функција прихвата листу l и враћа листу l'.
    l' је иста као l на оним индексима који нису дељиви са three, а индекси који су дељиви са three,
    вредности у l на тим индексима су сортиране.
    >>> 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: list):
    """Ова функција прихвата листу l и враћа листу l', и то на тај начин да
    l' је иста као l на оним индексима који нису дељиви са 3, а индекси који су дељиви са 3,
    њихове вредности кореспондирају са индексима у l и сортиране су.
    >>> 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):
    """Враћа сортиране јединствене елементе у листи
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Врати сортиране јединствене елементе на листи
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Врати највећи елемент листе.
    >>> 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):
    """Врати максималан елемент на листи.
    >>> 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):
    """Враћа број појављивања броја 7 у целим бројевима мањим од n, који су дељиви са 11 или 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Прикажи као одговор колико се пута цифра 7 појављује у целим бројевима мањим од n а који су дељиви са 11 или 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Врати колико се пута цифра 7 појављује у целим бројевима мањим од н који су дељиви са 11 или 13.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Ова функција прима листу l и враћа листу l' такву да
    l' је идентична l на непарним индексима, док су њене вредности на парним индексима једнаке
    вредностима са парним индексима из l, али сортиране.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Ова функција узима листу л и враћа листу л' такву да
    л' је идентично л у непарним индексима, док су његове вредности на парним индексима једнаке
    на вредности парних индекса л, али сортирано.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Ова функција прихвата листу l и враћа листу l'.
    l' је иста као l на непарним индексима, а вредности на парним индексима
    су сортиране вредности парних индекса из l.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    Три групе карактера се циклично померају да би се вратио кодирани низ.
    """
    # Поделимо низ на групе. Свака група има дужину 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # Циклично померамо елементе сваке групе. Прескачемо групе које имају мање од 3 елемента.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    Прима кодирани низ из функције encode_cyclic као улаз и враћа декодирани низ.
    """

def encode_cyclic(s: str):
    """
    враћа кодирани стринг циклусом група од три карактера.
    """
    # подели стринг на групе. Сваки од дужине 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # елементи циклуса у свакој групи. Осим ако група има мање елемената од 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    takes as input string encoded with encode_cyclic function. Returns decoded string.
    """

def encode_cyclic(s: str):
    """
    враћа кодирани string цикличним померањем група од три карактера.
    """
    # подели string на групе. Свака има дужину 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # циклично померамо елементе сваке групе. Осим ако група има мање од 3 елемената.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    узима улазни string кодриан са encode_cyclic функциом. Враћа декодирани string.
    """


def prime_fib(n: int):
    """
    prime_fib враћа n-ти број који је истовремено Фибоначијев број и прост број.
    >>> 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 враћа n-ти број који је истовремено Фиборначијев број и прост број.
    >>> 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 враћа n-ти број који је Фибоначијев број и истовремено је прост број.
    >>> 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):
    """
    Функција triples_sum_to_zero прихвата листу целих бројева као улаз.
    Ако листа садржи три различита елемента чији је збир 0, враћа True,
    иначе враћа 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 прихвата листу целих бројева као улаз.
    Враћа True ако листа садржи три различита елемента
    чији је збир 0, иначе враћа 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([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):
    """
    Замислимо да је пут савршено прав и да се протеже у бесконачност.
    Постоји n аутомобила који се крећу слева надесно; истовремено постоји n аутомобила,
    који се крећу здесна налево. Обе групе аутомобила су у почетку веома далеко једна од друге.
    Сваки аутомобил се креће истом брзином. Када се аутомобил који се креће слева надесно
    сретне са аутомобилом који се креће здесна налево, то називамо сударом.
    Међутим, аутомобили су изузетно издржљиви и јаки; као резултат тога настављају
    свој пут као да се никакав судар није догодио.

    Ова функција враћа број таквих судара.
    """

def car_race_collision(n: int):
    """
    Замислимо да је пут савршено прав и да се протеже у бесконачност.
    Постоји n аутомобила који се крећу слева надесно; истовремено постоји n аутомобила
    који се крећу здесна налево. Обе групе аутомобила су у почетку веома далеко једна од друге.
    Сваки аутомобил се креће истом брзином. Када се аутомобил који се креће слева надесно
    сретне са аутомобилом који се креће здесна налево, то називамо сударом.
    Међутим, аутомобили су изузетно издржљиви и јаки; као резултат тога настављају
    свој пут као да се никакав судар није догодио.

    Ова функција враћа број таквих судара.
    """

def car_race_collision(n: int):
    """
    Замислите пут који је представљен као савршено права бесконачна линија.
    n број аутомобила вози с лева на десно;  истовремено, други скуп n аутомобила
    вози с десна на лево.   Два скупа аутомобила започињу вожњу као веома удаљени
    једни од других.  Сви аутомобили се крећу истом брзином.  За два аутомобила се каже да су се сударила
    када ауто који се креће с лева на десно удари у ауто који се креће с десна улево.
    Међутим, аутомобили су изузетно издржљиви и јаки; као резултат тога, аутомобили настављају да се крећу
    својом путањом као да до судара није ни дошло.

    Ова функција пружа одговор у виду броја таквих судара.
    """


def incr_list(l: list):
    """Враћа листу чији су елементи увећани за 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):
    """Као одговор врати листу са елементима увећаним за 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):
    """Повратна листа са елементима увећаним за 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 прима листу целих бројева као улаз.
    враћа True ако у листи постоје два различита елемента чији је
    збир нула, и 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([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 прима листу integer-а као улаз.
    Враћа True ако постоје два различита елемента у листи чији је збир нула,
    иначе враћа 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):
    """Промените базу улазног броја x у другу базу.
    Враћа низ као репрезентацију конвертованог броја.
    База је мања од 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Промените нумеричку основу улазног броја к у базу.
    врати приказ стрингова након конверзије.
    основни бројеви су мањи од 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Промените базу улазног броја x у другу базу.
    Враћа stringрепрезентацију конвертованог броја.
    База бројева је мања од 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Дате дужине странице и висине, враћа површину троугла.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Датa дужина странице и висина враћа површину троугла.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Датa је дужина једне странице троугла и висина. Враћа површину троугла.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """Бројчани низ Fib4 је низ сличан Фибоначијевом низу који је дефинисан на следећи начин:
    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).
    Напишите функцију за ефикасно израчунавање н-тог елемента низа бројева фиб4.  Не користите рекурзију.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 секвенца је слична Фибоначи секвенци и дефинисана је на следећи начин:
    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).
    Напишите функцију за ефикасно израчунавање n-тог елемента Fib4 секвенце. Не користите рекурзију.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """Fib4 бројчана секвенца је слична Фибоначијевој секвенци и дефинисана је на следећи начин:
    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).
    Напишите функцију за ефикасно израчунавање n-тог елемента fib4 бројчане секвенце.  Не користите рекурзију.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Враћа медијану елемената листе l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Врати медијану елемената на листи l.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Проверите да ли је дати стринг палиндром
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Провери да ли је дати низ палиндром.
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Проверите да ли је дати текст палиндром
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """Враћа остатак од 2^n модуло p (обрати пажњу на бројеве).
    >>> 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):
    """Враћа остатак 2^n подељеног са p (обрати пажњу на податке).
    >>> 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):
    """Вратите 2^н по модулу п (имајте на уму бројеве).
    >>> 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):
    """
    Враћа енкодирани стринг тако што сваки карактер помера за 5 позиција у абецеди.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Узима улазни стринг кодиран функцијом encode_shift. Враћа декодирани стринг.
    """

def encode_shift(s: str):
    """
    Враћа низ карактера у којем је сваки карактер кодиран померањем за 5 позиција у абецеди.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    Прихвата низ карактера који је кодиран функцијом encode_shift и враћа декодирани низ карактера.
    """

def encode_shift(s: str):
    """
    враћа кодирани стринг померањем сваког знака за 5 у абецеди.
    """
    повратак "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    узима као улазни низ кодиран функцијом енцоде_схифт. Враћа декодирани низ.
    """


def remove_vowels(text):
    """
    ремове_вовелс је функција која узима стринг и враћа низ без самогласника.
    >>> 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 је функција која прихвата низ карактера и враћа низ без самогласника.
    >>> 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 је функција која узима низ и даје као одговор низ без самогласника.
    >>> 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):
    """Враћа True ако су сви бројеви у листи l мањи од threshold t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Вратите тачно ако су сви бројеви на листи л испод прага t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Врати Тачно ако су сви бројеви на листи л испод прага t.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Сабира два броја, x и y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Додајте два броја к и и
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Проверите да ли две речи садрже исте карактере.
    >>> 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 same_chars(s0: str, s1: str):
    """
    Проверите да ли две речи имају исте знакове.
    >>> 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 same_chars(s0: str, s1: str):
    """Проверите да ли две речи имају исте карактере.
    >>> 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):
    """Враћа n-ти Фибоначијев број.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """Врати н-ти Фибоначијев број.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ brackets је стринг који садржи знакове "<" и ">".
    Враћа True ако свака отворена заграда има одговарајућу затворену заграду.

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

def correct_bracketing(brackets: str):
    """ заграде су низ од "<" and ">".
    ретурн Тачно ако свака почетна заграда има одговарајућу заграду.

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


def monotonic(l: list):
    """Враћа True ако су елементи листе монотоно растући или опадајући.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """Повратак Тачно је да се елементи листе монотоно повећавају или смањују.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Враћа сортиране јединствене заједничке елементе две листе.
    >>> 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):
    """Врати сортиране јединствене заједничке елементе за две листе.
    >>> 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):
    """Врати јединствене заједничке елементе две листе, који су сортирани.
    >>> 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):
    """Враћа највећи прости делилац n. Претпоставимо да је n > 1 и да није прост број.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Враћа највећи прост број који је делилац броја n. Претпоставља се да је n > 1 и да није прост број.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n је функција која сабира бројеве од 1 до 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 sum_to_n(n: int):
    """сум_то_н је функција која сабира бројеве из 1 to 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 је низ карактера који садржи знакове „(" и „)".
    Ако свака отворена заграда има одговарајућу затворену заграду, враћа True.

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

def correct_bracketing(brackets: str):
    """ brackets је низ од "(" and ")".
    враћа True ако свака отворена заграда има одговарајућу brackets за затварање.

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

def correct_bracketing(brackets: str):
    """ brackets је string од "(" и ")".
    враћа True ако свака отворена заграда има одговарајућу затворену заграду.

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


def derivative(xs: list):
    """ xs представља коефицијенте полинома.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
    Враћа извод овог полинома у истом формату.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ кс представљају коефицијенте полинома.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Повратни извод овог полинома у истом облику.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """FibFib бројни низ је низ сличан Фибоначијевом низу који је дефинисан на следећи начин:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Напишите функцију за ефикасно израчунавање n-тог елемента fibfib бројног низа.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """FibFib бројчани низ је низ сличан Фибоначијевом низу који је дефинисан на следећи начин:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Напишите функцију за ефикасно израчунавање n-th елемента низа бројева fibfib.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """The FibFib секвенца је слична Фибоначијевој секвенци и дефинисана је на следећи начин:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Напишите функцију за ефикасно израчунавање n-тог елемента ФибФиб секвенце..
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Додајте више тест случајева.
"""

def vowels_count(s):
    """Напишите функцију vowels_count која прихвата низ као улаз
    и враћа број самогласника у низу. У овом случају, самогласници су
    'a', 'e', 'i', 'o', 'u'. 'y' се сматра самогласником само ако је на крају речи.

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Додајте још тест случајева.
"""

def vowels_count(s):
    """Напишите функцију вовелс_цоунт која узима низ који представља
    реч као улаз и враћа број самогласника у низу.
    Самогласници у овом случају су 'а', 'е', 'и', 'о', 'у'. Овде је 'и' такође а
    самогласник, али само када је на крају дате речи.

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Додајте више тест случајева.
"""

def vowels_count(s):
    """Напишите функцију vowels_count која прихвата стринг који представља
    реч као улаз и враћа број самогласника у стрингу.
    У овом случају, самогласници су 'a', 'e', 'i', 'o', 'u'. Овде, 'y' је такође
    самогласник, али само ако је на крају речи.

    Пример:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Кружно помера цифре целог броја x удесно за количину одређену параметром shift
    и враћа резултат као низ карактера.
    Ако је shift већи од броја цифара, обрће цифре и враћа их.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Кружно померајте цифре целог броја x, померајте цифре удесно за померањем
    и вратите резултат као стринг.
    If shift > number of digits, return digits reversed.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Кружно помери цифре целог броја x, помери цифре удесно за shift
    и врати резултат као string.
    Ако је shift > броја цифара, враћа шифре у обрнутом редоследу:
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Задатак
    Напиши функцију која прихвата стринг као улаз и враћа збир ASCII кодова великих слова.

    Примери:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Задатак
    Напишите функцију која узима стринг као улаз и враћа збир само горњих знакова'
    АСЦИИ кодови.

    Примери:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Задатак
    Напиши функцију која узима string као улаз и враћа збир само ASCII кодова великих слова.

    Примери:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    У овом задатку, биће вам дат стринг који представља број јабука и поморанџи
    које се налазе у корпи са воћем. Ова корпа садржи
    јабуке, поморанџе и манго. Дат је стринг који представља укупан број
    поморанџи и јабука и цео број који представља укупан број воћака у корпи.
    Вратите број мангоа у корпи.
    на пример:
    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):
    """
    У овом задатку, добићете низ који представља одређени број јабука и поморанџи
    који су распоређени у корпи воћа коју ова корпа садржи
    јабуке, поморанџе и воће манга. С обзиром на низ који представља укупан број
    поморанџе и јабуке и цео број који представља укупан број воћа
    у корпу вратите број плодова манга у корпи.
    за пример:
    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):
    """
    У овом задатку, добићете низ који представља одређени број јабука и поморанџи
    који су распоређени у корпу воћа коју ова корпа садржи
    јабуке, поморанџе и воће манга. С обзиром на низ који представља укупан број
    поморанџе и јабуке и цео број који представља укупан број воћа
    у корпу вратите број плодова манга у корпи.
    на пример:
    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):
    """
    Низ представља грану дрвета која је дата, овај низ садржи чворове као ненегативне целе бројеве.
    Ваш задатак је да изаберете и вратите један чвор.
    Изабрани чвор мора бити чвор са најмањом парном вредношћу.
    Ако постоји више чворова са истом најмањом парном вредношћу, вратите чвор са најмањим индексом.

    Изабрани чвор треба вратити као листу [најмања вредност, индекс те вредности].
    Ако нема парних вредности или је дати низ празан, вратите празну листу.

    Пример 1:
        Улаз: [4,2,3]
        Излаз: [2, 1]
        Објашњење: 2 је најмања парна вредност и 2 има најмањи индекс.

    Пример 2:
        Улаз: [1,2,3]
        Излаз: [2, 1]
        Објашњење: 2 је најмања парна вредност и 2 има најмањи индекс.

    Пример 3:
        Улаз: []
        Излаз: []

    Пример 4:
        Улаз: [5, 0, 3, 0, 4, 2]
        Излаз: [0, 1]
        Објашњење: 0 је најмања вредност, али постоје два броја 0,
                     тако да изаберите први 0. То је најмањи индекс.

    Ограничења:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Дат је низ који представља грану стабла са не-негативним целобројним чворовима
    Ваш задатак је да изаберете и вратите један чвор.
    Изабрани чвор мора бити чвор са најмањом парном вредношћу.
    Ако постоји више чворова са истом најмањом парном вредношћу, вратите чвор са најмањим индексом.

    Изабрани чвор треба да буде враћен у листи, [ најмања_вредност, његов индекс ],
    Ако нема парних вредности или је дати низ празан, вратите [].

    Пример 1:
        Улаз: [4,2,3]
        Излаз: [2, 1]
        Објашњење: 2 је најмања парна вредност и 2 има најмањи индекс.

    Пример 2:
        Улаз: [1,2,3]
        Излаз: [2, 1]
        Објашњење: 2 је најмања парна вредност и 2 има најмањи индекс.

    Пример 3:
        Улаз: []
        Излаз: []

    Пример 4:
        Улаз: [5, 0, 3, 0, 4, 2]
        Излаз: [0, 1]
        Објашњење: 0 је најмања вредност, али постоје два броја нула,
                     тако да изаберите прву нулу, која има најмањи индекс.

    Ограничења:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Дат је низ који представља грану дрвета које има ненегативне цјелобројне чворове
    ваш задатак је да ишчупате један од чворова и вратите га.
    Уклоњени чвор треба да буде чвор са најмањом парном вредношћу.
    Ако се пронађе више чворова са истом најмањом парном вредношћу, вратите чвор који има најмањи индекс.

    Одузети чвор треба да буде враћен на листи, [ најмања_вредност, њен индекс ],
    Ако нема парних вредности или је дати низ празан, вратите [].

    Пример 1:
        Улаз: [4,2,3]
        Излаз: [2, 1]
        Објашњење: 2 има најмању парну вредност, а 2 најмањи индекс.

    Пример 2:
        Улаз: [1,2,3]
        Излаз: [2, 1]
        Објашњење: 2 има најмању парну вредност, а 2 најмањи индекс.

    Пример 3:
        Улаз: []
        Излаз: []

    Пример 4:
        Улаз: [5, 0, 3, 0, 4, 2]
        Излаз: [0, 1]
        Објашњење: 0 је најмања вредност, али постоје две нуле,
                     па ћемо изабрати прву нулу, која има најмањи индекс.

    Ограничења:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Дата је непразна листа позитивних целих бројева. Враћа највећи цео број који је већи од 0 и чија је учесталост већа или једнака његовој вредности.
    Учесталост целог броја је број његових појављивања у листи.
    Ако такав број не постоји, враћа -1.
    Пример:
        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):
    '''
    Добијате непразну листу позитивних целих бројева. Врати највећи цео број који је већи од
    нула, и има фреквенцију већу или једнаку вредности самог целог броја.
    Учесталост целог броја је колико пута се појављује на листи.
    Ако таква вредност не постоји, вратите -1.
    Примери:
        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):
    '''
    Дата вам је попуњена листа позитивних целих бројева. Прикажи највећи цео број који је већи од
    нула и има учесталост која је једнака или већа од вредности целог броја.
    Учесталост целог броја је број пута колико се понавља на листи.
    Уколико такав број не постоји, прикажи -1.
    Примери:
        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):
    '''
    Ако је дата листа целих бројева, враћа листу у чудном редоследу.
    Чудно сортирање почиње са најмањом вредношћу, затим следи највећа вредност од преосталих бројева,
    затим најмања вредност, и тако даље.

    Пример:
    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):
    '''
    Задата листа целих бројева, вратите листу чудним редоследом.
    Чудно сортирање, када почнете са минималном вредношћу,
    затим максимум преосталих целих бројева, затим минимум и тако даље.

    Примери:
    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):
    '''
    Ако су дате дужине три стране троугла и те три стране чине важећи троугао,
    враћа површину троугла заокружену на две децимале.
    Ако не, враћа -1.
    Да би три стране чиниле важећи троугао, збир две стране мора бити већи од треће стране.
    Пример:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Дате су дужине три стране троугла. Вратите област од
    троугао заокружен на 2 децимале ако три странице чине важећи троугао.
    У супротном врати -1
    Три странице чине важећи троугао када је збир било које две странице већи
    него трећа страна.
    Пример:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Напишите функцију која враћа True ако објекат q може да лети, и False ако не може.
    Објекат q ће летети ако је балансиран (тј. ако је палиндромска листа) и ако је збир његових елемената мањи или једнак максималној тежини w.

    Пример:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 мањи од максималне могуће тежине, али није балансиран.

    will_it_fly([3, 2, 3], 1) ➞ False
    # балансиран је, али 3+2+3 је веће од максималне тежине.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 је мањи од максималне тежине и балансиран је.

    will_it_fly([3], 5) ➞ True
    # 3 је мањи од максималне тежине и балансиран је.
    '''

def will_it_fly(q, w):
    '''
    Напишите функцију која враћа True ако објект q може да лети, а False у супротном.
    Објекат q може да лети ако је избалансиран (то је палиндромска листа) и ако је збир његових елемената мањи или једнак максималној могућој тежини w.

    Пример:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 је мање од максималне могуће тежине, али није избалансиран.

    will_it_fly([3, 2, 3], 1) ➞ False
    # избалансиран је, али 3+2+3 је више од максималне могуће тежине.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 је мање од максималне могуће тежине, и избалансиран је.

    will_it_fly([3], 5) ➞ True
    # 3 је мање од максималне могуће тежине, и избалансиран је.
    '''

def will_it_fly(q,w):
    '''
    Функција која враћа True ако објекат q може да лети, иначе враћа False.
    Објекат q може да лети ако је избалансиран (палиндром листа) и збир његових елемената је мањи или једнак максималној могућој тежини w.

    Пример:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 је мање од максималне могуће тежине, али није избалансиран.

    will_it_fly([3, 2, 3], 1) ➞ False
    # Избалансиран је, али 3+2+3 је веће од максималне могуће тежине.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 је мање од максималне могуће тежине и избалансиран је.

    will_it_fly([3], 5) ➞ True
    # 3 је мање од максималне могуће тежине и избалансиран је.
    '''


def smallest_change(arr):
    """
    Дат је низ целих бројева arr, пронађите минималан број елемената које
    треба променити да би низ постао палиндромски. Палиндромски низ је низ који
    се чита исто и са почетка и са краја. У једној промени, можеш променити један елемент у било који други елемент.

    На пример:
    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):
    """
    Дата је листа целих бројева arr, пронађите минималан број елемената
    које треба променити да би листа постала симетрична. Симетрична
    листа је она која је иста када се чита слева надесно и здесна налево.
    Једном променом може се заменити један елемент другим.

    Пример:
    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):
    """
    Дата је листа integer-а arr, пронађите минималан број елемената који
    треба да се промене да би низ постао палиндромски. Палиндромски низ је низ који
    се чита исто унапред и уназад. У једној промени, можете променити један елемент у било који други елемент.

    На пример:
    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):
    '''
    Напишите функцију која прихвата две листе стрингова и враћа листу која има
    укупан број карактера у свим стринговима мањи од друге листе.

    Ако обе листе имају исти број карактера, вратите прву листу.

    Примери
    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):
    '''
    Напишите функцију која прихвата две листе стрингова и враћа листу која има
    укупан број знакова у свим стринговима листе мањи од друге листе.

    ако две листе имају исти број знакова, вратите прву листу.

    Примери
    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):
    '''
    Напиши функцију која прихвата две листе са низовима карактера и враћа листу са свим
    бројем карактера низова који су мањи од друге листе.

    Ако обе листе имају исти број карактера, врати прву листу.

    Пример
    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):
    """Напишите функцију која враћа true ако је дат број производ три простих бројева
    а false у супротном.
    Знајући да је (a) мање од 100.
    Пример:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Напишите функцију која враћа тачно ако је дати број множење 3 проста броја
    а иначе лажна.
    Знајући да је (а) мање од 100.
    Пример:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Напиши функцију која као одговор даје true ако је дати број производ 3 проста броја
    а false у другом случају.
    Знајући да је (a) мање од 100.
    Пример:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """Твој задатак је да напишеш функцију која враћа true ако је број x једноставан
    степен n, и false ако није.
    x је једноставан степен n ако је n**int=x.
    Пример:
    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):
    """Ваш задатак је да напишете функцију која враћа True ако је број x једноставна
    моћ броја n, и false у другим случајевима.
    Број x је једноставна моћ броја n ако је n**int(x) = x
    Примери:
    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):
    """Твој задатак је да напишеш функцију која враћа true ако је број x једноставни
    степен од n, и false ако није.
    x је једноставни степен од n ако је n**int=x
    На пример:
    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):
    '''
    Напишите функцију која узима цео број a и враћа True
    ако је тај цео број број трећи степен неког целог броја.
    Напомена: можете претпоставити да је улаз увек ваљидан.
    Примери:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Напишите функцију која узима цео број а и враћа Тачно
    ако је овај ингер коцка неког целог броја.
    Напомена: можете претпоставити да је унос увек важећи.
    Примери:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """"""Задат вам је задатак да напишете функцију која прима
    хексадецимални број као стринг и броји број хексадецималних
    цифара које су просте (прост број је природан број већи од 1
    који није производ два мања природна броја).
    Хексадецималне цифре су 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    Прости броји су 2, 3, 5, 7, 11, 13, 17,...
    Дакле, треба да одредите број следећих цифара: 2, 3, 5, 7,
    B (=decimal 11), D (=decimal 13).
    Напомена: Можете претпоставити да је улаз увек исправан или празан стринг,
    а симболи A, B, C, D, E, F су увек са великим словима.
    Примери:
    За num = "AB" резултат треба да буде 1.
    За num = "1077E" резултат треба да буде 2.
    За num = "ABED1A33" резултат треба да буде 4.
    За num = "123456789ABCDEF0" резултат треба да буде 6.
    За num = "2020" резултат треба да буде 2.
    """

def hex_key(num):
    """Добили сте задатак да напишете функцију која прима
    хексадецимални број као стринг и броји хексадецимални број
    цифре које су прости бројеви (прост број, или прост, је природан број
    већи од 1 који није производ два мања природна броја).
    Хексадецималне цифре су 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, А, Б, Ц, Д, Е, Ф.
    Прости бројеви су 2, 3, 5, 7, 11, 13, 17,...
    Дакле, морате одредити број следећих цифара: 2, 3, 5, 7,
    Б (=децимала 11), Д (=децимала 13).
    Напомена: можете претпоставити да је унос увек тачан или празан стринг,
    и симболи А,Б,Ц,Д,Е,Ф су увек велика слова.
    Примери:
    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 hex_key(num):

    """Добили сте задатак да напишете функцију која прима
    хексадецимални број као низ карактера и броји хексадецимални број
    цифре које су прости бројеви (прост број, или прост, је природан број
    већи од 1 који није производ два мања природна броја).
    Хексадецималне цифре су 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, А, Б, Ц, Д, Е, Ф.
    Прости бројеви су 2, 3, 5, 7, 11, 13, 17,...
    Дакле, морате одредити број следећих цифара: 2, 3, 5, 7,
    Б (=децимала 11), Д (=децимала 13).
    Напомена: можете претпоставити да је унос увек тачан или празан низ карактера,
    а симболи A,B,C,D,E,F су увек велика слова.
    Примери:
    For num = "AB" излаз треба да буде 1.
    For num = "1077E" излаз треба да буде 2.
    For num = "ABED1A33" излаз треба да буде 4.
    For num = "123456789ABCDEF0" излаз треба да буде 6.
    For num = "2020" излаз треба да буде 2.
    """


def decimal_to_binary(decimal):
    """Добићете број у децималном облику и ваш задатак је да га конвертујете у
    бинарни формат. Функција треба да врати стринг, са сваким карактером који представља бинарни запис
    број. Сваки знак у низу ће бити '0' или '1'.

    Биће још пар знакова 'db' на почетку и на крају стринга.
    Додатни знакови су ту да помогну у формату.

    Примери:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Добићете број у децималном облику и ваш задатак је да га конвертујете у
    бинарни формат. Функција треба да врати стринг, са сваким карактером који представља бинарни запис
    број. Сваки знак у низу ће бити '0' или '1'.

    Биће још пар знакова 'дб' на почетку и на крају стринга.
    Додатни знакови су ту да помогну у формату.

    Примери:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """

def decimal_to_binary(decimal):
    """Број је дат у децималном формату, а задатак је да се тај број конвертује у бинарни формат.
    Функција треба да врати такав низ карактера у коме сваки карактер представља једну бинарну цифру.
    Сваки карактер у низу ће бити „0" или „1".

    На почетак и крај низа додају се „db" карактери.
    Ови додати карактери постоје ради подршке форматирању.

    Пример:
    decimal_to_binary(15)   # Враћа "db1111db"
    decimal_to_binary(32)   # Враћа "db100000db"
    """


def is_happy(s):
    """Дат вам је стринг s.
    Ваш задатак је да проверите да ли је стринг срећан или није.
    Стринг је срећан ако је његова дужина најмање 3 и свака 3 узастопна слова су различита.
    На пример:
    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):
    """Дат је низ карактера s.
    Задатак је утврдити да ли је низ карактера срећан.
    Да би низ карактера био срећан, мора бити дугачак најмање 3 карактера и 3 узастопна карактера морају бити различита.
    Пример:
    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):
    """Дат вам је string s.
    Ваш задатак је да проверите да ли је string срећан или не.
    String је срећан ако му је дужина бар 3, а сва три узастопна слова су различита.
    На пример:
    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):
    """Последња недеља семестра, и наставник мора да оцењује ученике.
    Наставник прави сопствени алгоритам за оцењивање.
    Проблем је што је изгубио код који је користио за оцењивање.
    Дата је листа неких студентских GPA, и потребно је написати
    функцију која може да врати листу оцена према следећој табели:
             GPA       |    Оцена
              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

    Пример:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Последња је недеља семестра, а наставница мора да додели оцене
    ученицима. Наставница прави сопствени алгоритам за оцењивање.
    Једини проблем је то, што је изгубила код који је користила.
    Дала вам је листу GPA за неке ученике, и потребно је да напишете
    функцију која ће као излаз дати листу словних оцена према следећој табели:
             GPA       |    Словна оцена
              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

    Пример:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """

def numerical_letter_grade(grades):
    """Последња је недеља семестра и наставник мора да да оцене
    студентима. Наставница прави сопствени алгоритам за оцењивање.
    Једини проблем је што је изгубила шифру коју је користила за оцењивање.
    Она вам је дала листу ГПА за неке ученике и морате да напишете
    функција која може да избаци листу словних оцена користећи следећу табелу:
             ГПА |    Леттер оцена
              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

    Пример:
    grade_equation([4.0, 3, 1.7, 2, 3.5]) ==> ['A+', 'B', 'C-', 'C', 'A-']
    """


def prime_length(string):
    """Напишите функцију која прихвата стринг и враћа True ако је дужина стринга
    прост број, или False у супротном.
    Примери
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Напишите функцију која узима стринг и враћа Труе ако је стринг
    дужина је прост број или нетачно у супротном
    Примери
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Напишите функцију која узима низ и враћа True ако је низ
    дужина је прост број или враћа False у супротном
    Примери
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Ако је дат позитиван цео број n, враћа број позитивних целих бројева који имају n цифара и почињу или се завршавају цифром 1.
    """

def starts_one_ends(n):
    """
    Дат је позитиван цео број n, врати број бројева од n цифара
    позитивни цели бројеви који почињу или завршавају са 1.
    """

def starts_one_ends(n):
    """
    Дат је позитиван цео број н, врати број бројева од н цифара
    позитивни цели бројеви који почињу или завршавају са 1.
    """


def solve(N):
    """Ако је дат позитиван цео број N, враћа збир цифара у бинарном систему.

    Пример
        Ако је N = 1000, збир цифара је 1, и излаз треба да буде „1".
        Ако је N = 150, збир цифара је 6, и излаз треба да буде „110".
        Ако је N = 147, збир цифара је 12, и излаз треба да буде „1100".

    Променљива:
        @N цео број
             Услов: 0 ≤ N ≤ 10000.
    Излаз:
         Бинарни низ карактера
    """

def solve(N):
    """Дат позитиван цео број Н, врати укупан збир његових цифара у бинарном облику.

    Пример
        For N = 1000, the sum of digits will be 1 the output should be "1".
        For N = 150, the sum of digits will be 6 the output should be "110".
        For N = 147, the sum of digits will be 12 the output should be "1100".

    Променљиве:
        @N integer
             Ограничења: 0 ≤ N ≤ 10000.
    Излаз:
         низ бинарног броја
    """


def add(lst):
    """Ако је дата не-празна lst листа, која садржи целе бројеве,
    сабери парне елементе на непарним индексима.

    Пример:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Ако је дата непразна листа целих бројева lst. додајте парне елементе који су у непарним индексима..

    Примери:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """С обзиром на непразну листу целих бројева лст. додајте парне елементе који су у непарним индексима..

    Примери:
        add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Прима карактерни низ и враћа његову сортирану верзију.
    Сортирана верзија карактерног низа је онај низ где је свака реч (раздвојена размаком)
    замењена карактерима који су у растућем редоследу према њиховој ASCII вредности.
    Напомена: Редослед речи и размака мора остати исти у реченици.

    Пример:
    anti_shuffle('Hi') враћа 'Hi'.
    anti_shuffle('hello') враћа 'ehllo'.
    anti_shuffle('Hello World!!!') враћа 'Hello !!!Wdlor'.
    """

def anti_shuffle(s):
    """
    Напишите функцију која узима низ и враћа његову уређену верзију.
    Сортирана верзија низа, је низ у коме су све речи (раздвојене размаком)
    се замењују новом речју где су сви знакови распоређени у
    растући поредак на основу ascii вредности.
    Напомена: Задржите редослед речи и празних места у реченици.

    На пример:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Напишите функцију која узима стринг и враћа његову уређену верзију.
    Наређена верзија стринга, је стринг у коме су све речи (раздвојене размаком)
    се замењују новом речју где су сви знакови распоређени у
    растући ред на основу асции вредности.
    Напомена: Задржите редослед речи и празних места у реченици.

    на пример:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Дводимензионални подаци су дати у облику угнежђених листа.
    Ово је слично матрици, али за разлику од матрице, сваки ред може садржати различит број колона.
    Када су дати lst и цео број x, пронађите цео број x у листи
    и вратите листу парова координата - (ред, колона) [(x1, y1), (x2, y2) ...].
    Координате су сортиране по редовима у растућем редоследу.
    Даље, координате редова су сортиране по колонама у опадајућем редоследу.

    Пример:
    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):
    """
    Дати су дводимензионални подаци, груписани према корену речи,
    који је сличан матриксу, међутим, за разлику од матрице,
    сваки ред може да садржи различит број колона.
    За дати lst, и цели број x, пронађи целе бројеве x у листи,
    и врати као одговор листу tuples, [(x1, y1), (x2, y2) ...] тако да је
    сваки tuple координата - (ред, колона), који почиње 0.
    Прво сортирајте координате по редовима у растућем редоследу.
    Такође, сортирајте координате редова по колонама у опадајућем редоследу.

    Примери:
    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):
    """
    Дат низ ненегативних целих бројева, врати копију датог низа након сортирања,
    сортираћете дати низ у растућем редоследу ако је збир (прва вредност индекса, последња вредност индекса) непаран,
    или га сортирајте у опадајућем редоследу ако је збир (прва вредност индекса, последња вредност индекса) паран.

    Напомена:
    * не мењајте дати низ.

    Примери:
    * 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):
    """
    Дат је низ не-негативних целих бројева, враћа копију низа који је сортиран.
    Ако је збир вредности на првом и последњем индексу непаран, сортира низ у растућем редоследу,
    ако је збир паран, сортира низ у опадајућем редоследу.

    Напомена:
    * Не мења дати низ.

    Пример:
    * 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):
    """Напишите функцију encrypt која прихвата string као аргумент и враћа string шифрован
    ротирањем абецеде.
    Абецеда се ротира тако да се слова померају за два пута два места унапред.
    На пример:
    encrypt('hi') враћа 'lm'
    encrypt('asdfghjkl') враћа 'ewhjklnop'
    encrypt('gf') враћа 'kj'
    encrypt('et') враћа 'ix'
    """

def encrypt(s):
    """Креирајте функцију encrypt која прихвата низ карактера као параметар и
    враћа низ са обрнутим словима. Слова треба
    ротирати за две позиције унапред помножено са два.
    Пример:
    encrypt('hi') враћа 'lm'.
    encrypt('asdfghjkl') враћа 'ewhjklnop'.
    encrypt('gf') враћа 'kj'.
    encrypt('et') враћа 'ix'.
    """

def encrypt(s):
    """Креирајте функцију encrypt која прихвата стринг као параметар и
    враћа низ који је енкриптован са ротираним алфабетом.
    Алфабет треба да буде померен на такав начин да се слова
    померају наниже за за два пута два места.
    На пример:
    encrypt('hi') враћа 'lm'
    encrypt('asdfghjkl') враћа 'ewhjklnop'
    encrypt('gf') враћа 'kj'
    encrypt('et') враћа 'ix'
    """


def next_smallest(lst):
    """
    Дата је листа целих бројева.
    Напишите функцију next_smallest() која враћа други најмањи елемент листе.
    Ако такав елемент не постоји, вратите 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 next_smallest(lst):
    """
    Добијате листу целих бројева.
    Напишите функцију нект_смаллест() која враћа 2. најмањи елемент листе.
    Врати Ноне ако не постоји такав елемент.

    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):
    """
    Дата је листа integer-а.
    Напишите функцију next_smallest() која враћа други најмањи елемент листе.
    Ако такав елемент не постоји, вратите 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):
    """
    Дат је низ карактера, твој задатак је да пребројиш број досадних реченица.
    Досадна је реченица ако почиње са „I".
    Реченице су раздвојене са „.", „?" или „!".

    Пример:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Добићете низ речи, а ваш задатак је да пребројите број
    од досаде. Досада је реченица која почиње речју „ја“.
    Реченице су раздвојене '.', '?' или '!'.

    на пример:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Биће ти дат низ речи, а твој задатак је да пребројиш
    досаде. Досада је реченица која почиње са словом "I".
    Реченице су раздвојене са '.', '?' или '!'.

    На пример:
    >>> 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):
    '''
    Направите функцију која узима 3 броја.
    Враћа тачно ако је један од бројева једнак збиру друга два, а сви бројеви су цели бројеви.
    Враћа нетачно у свим другим случајевима.

    Примери
    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):
    '''
    Креирајте функцију која прихвата 3 броја..
    Враћа True ако је један од ова три броја једнак збиру преостала два броја и сва три броја су цела броја.
    Враћа False у другим случајевима.

    Примери
    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):
    '''
    Креирајте функцију која прихвата 3 броја.
    Враћа true ако је један од ова три броја једнак збиру преостала два броја, и сва ти броја су цела броја.
    Враћа false у било ком другом случају.

    Примери
    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 encode(message):
    """
    Напишите функцију која узима поруку и кодира на такав
    начин да мења велика и мала слова свих слова, замењује све самогласнике
    у поруци словом које се појављује 2 места испред
    тог самогласника у енглеском алфабету.
    Претпоставимо само слова.

    Примери:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Напиши функцију која прима поруку и замењује велика слова малим, а мала великим,
    затим замењује све самогласнике у поруци словом које је 2 позиције испред у енглеској абецеди.
    Претпоставимо да постоје само абецедни карактери.

    Пример:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Напишите функцију која узима поруку и кодира у такву
    начин на који мења велика и мала слова свих слова, замењује све самогласнике
    порука са словом које се појављује 2 места испред тога
    самогласник у енглеском алфабету.
    Претпоставимо само слова.

    Примери:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Дат је списак целих бројева.
    Потребно је пронаћи највећи прост број и вратити збир његових цифара.

    Примери:
    За lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] излаз треба да буде 10
    За lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] излаз треба да буде 25
    За lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] излаз треба да буде 13
    За lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] излаз треба да буде 11
    За lst = [0,81,12,3,1,21] излаз треба да буде 3
    За lst = [0,8,1,2,1,7] излаз треба да буде 7
    """

def skjkasdkd(lst):
    """Дат је списак целих бројева.
    Потребно је пронаћи највећи прост број и вратити збир његових цифара.

    Примери:
    For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] тада излаз треба да буде 10
    For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] тада излаз треба да буде 25
    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] тада излаз треба да буде 13
    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] тада излаз треба да буде 11
    For lst = [0,81,12,3,1,21] тада излаз треба да буде 3
    For lst = [0,8,1,2,1,7] тада излаз треба да буде 7
    """

def skjkasdkd(lst):
    """Дат је списак целих бројева.
    Потребно је пронаћи највећи прост број и вратити збир његових цифара.

    Пример:
    За lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] тада излаз треба да буде 10.
    За lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] тада излаз треба да буде 25.
    За lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] тада излаз треба да буде 13.
    За lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] тада излаз треба да буде 11.
    За lst = [0,81,12,3,1,21] тада излаз треба да буде 3.
    За lst = [0,8,1,2,1,7] тада излаз треба да буде 7.
    """


def check_dict_case(dict):
    """
    Враћа True ако су сви кључеви у датом речнику или сви мала слова или сви велика слова,
    иначе враћа False.
    Ако је дати речник празан, функција треба да врати False.
    Пример:
    check_dict_case({"a":"apple", "b":"banana"}) треба да врати True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) треба да врати False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) треба да врати False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) треба да врати False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) треба да врати True.
    """

def check_dict_case(dict):
    """
    С обзиром на речник, враћа True ако су сви кључеви низови мала
    слова или сви кључеви низови велика слова, иначе враћа False.
    Ако је дати речник празан, функција треба да врати False.
    Примери:
    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 check_dict_case(dict):
    """
    Ако имате речник, вратите Труе ако су сви кључеви низови на нижем нивоу
    велика слова или сви кључеви су стрингови у великим словима, у супротном враћају Фалсе.
    Функција треба да врати Фалсе ако је дати речник празан.
    Примери:
    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.
    """