def count_up_to(n):
    """Прима ненегативан цео број и имплементира функцију која враћа низ првих целих бројева мањих од n који су простi бројеви.
    Пример:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """

def count_up_to(n):
    """Имплементирати функцију која узима ненегативан цео број и враћа низ од првих н
    цели бројеви који су прости бројеви и мањи од н.
    на пример:
    count_up_to(5) => [2,3]
    count_up_to(11) => [2,3,5,7]
    count_up_to(0) => []
    count_up_to(20) => [2,3,5,7,11,13,17,19]
    count_up_to(1) => []
    count_up_to(18) => [2,3,5,7,11,13,17]
    """


def multiply(a, b):
    """Довршите функцију која узима два цела броја и враћа
    производ њихових јединичних цифара.
    Претпоставимо да је унос увек валидан.
    Примери:
    multiply(148, 412) треба да се врати 16.
    multiply(19, 28) треба да се врати 72.
    multiply(2020, 1851) треба да се врати 0.
    multiply(14,-15) треба да се врати 20.
    """

def multiply(a, b):
    """Довршите функцију која узима два цела броја и враћа
    производ њихових јединичних цифара.
    Претпоставимо да је унос увек валидан.
    Примери:
    multiply(148, 412) should return 16.
    multiply(19, 28) should return 72.
    multiply(2020, 1851) should return 0.
    multiply(14,-15) should return 20.
    """

def multiply(a, b):
    """Довршите функцију која прима два цела броја и враћа
    производ њихових цифара у јединици.
    Претпоставимо да је улаз увек валидан.
    Пример:
    multiply(148, 412) треба да врати 16.
    multiply(19, 28) треба да врати 72.
    multiply(2020, 1851) треба да врати 0.
    multiply(14,-15) треба да врати 20.
    """


def count_upper(s):
    """
    Дата је низ карактера s, пребројте велика слова самогласника на парним индексима.

    Пример:
    count_upper('aBCdEf') враћа 1
    count_upper('abcdefg') враћа 0
    count_upper('dBBE') враћа 0
    """

def count_upper(s):
    """
    Дат је string s, пребројте велика слова самогласника на парним индексима.

    На пример:
    count_upper('aBCdEf') враћа 1
    count_upper('abcdefg') враћа 0
    count_upper('dBBE') враћа 0
    """

def count_upper(s):
    """
    Дати низ с, пребројите број самогласника великих слова у парним индексима.

    на пример:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


def closest_integer(value):
    '''
    Направите функцију која узима вредност (стринг) која представља број
    и враћа најближи целобројни број. Ако је број једнако удаљен
    од два цела броја, заокружи даље од нуле.

    Примери
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Напомена:
    Заокруживање даље од нуле значи да када је дати број једнако удаљен
    од два цела броја, цео број који треба вратити је онај који је
    најдаљи од нуле. На пример, closest_integer("14.5") треба
    вратити 15, а closest_integer("-14.5") треба вратити -15.
    '''

def closest_integer(value):
    '''
    Прихвати вредност која представља број (низ карактера) и
    направи функцију која враћа најближи цео број.
    Ако је број једнако удаљен од два цела броја, заокружи даље од 0.

    Пример
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Референца:
    Заокруживање даље од 0 значи да када је дати број једнако удаљен од два цела броја,
    цео број који треба вратити је онај који је најдаље од 0. На пример, у случају closest_integer("14.5")
    треба вратити 15, а у случају closest_integer("-14.5") треба вратити -15.
    '''

def closest_integer(value):
    '''
    Креирајте функцију која узима вредност (низ) која представља број
    и враћа му најближи цео број. Ако је број једнако удаљен
    од два цела броја, заокружити га даље од нуле.

    Примери
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Напомена:
    Заокруживање даље од нуле значи да ако је дати број једнако удаљен
    од два цела броја, онај који треба да вратите је онај који је
    најдаље од нуле. На пример closest_integer("14.5") треба
    да врати 15 и closest_integer("-14.5") треба да се врати -15.
    '''


def make_a_pile(n):
    """
    Ако је дат позитиван цео број n, потребно је направити гомилу камења са n нивоа.
    Први ниво садржи n каменова.
    Број камења на следећем нивоу:
        - ако је n непаран, онда следећи непаран број.
        - ако је n паран, онда следећи паран број.
    Враћа листу која садржи број камења на сваком нивоу. Овде елемент на индексу i
    представља број камења на (i+1) нивоу.

    Пример:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Ако је дат позитиван цео број n, потребно је направити гомилу камења са n нивоа.
    Први ниво садржи n каменова.
    Број каменова на следећем нивоу је:
        - следећи непаран број ако је n непаран.
        - следећи паран број ако је n паран.
    Враћа листу која садржи број каменова на сваком нивоу, где елемент на индексу
    i представља број каменова на нивоу (i+1).

    Примери:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Дат је позитиван цео број н, морате да направите гомилу од н нивоа камења.
    Први ниво има н камења.
    Број камења на следећем нивоу је:
        - следећи непаран број ако је н непаран.
        - следећи паран број ако је н паран.
    Врати број камења на сваком нивоу на листи, где је елемент у индексу
    и представља број камења у нивоу (i+1).

    Примери:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Добићете низ речи одвојених зарезом или размаком.
    Ваш задатак је да раздвојите низ на речи и вратите листу речи.

    Пример:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """

def words_string(s):
    """
    Добићете низ речи које су одвојене зарезима или размацима. Ваш задатак је
    поделите низ у речи и да вратите мноштво речи.

    На пример:
    words_string("Здраво, моје име је Џон") == ["Здраво", "моје", "име", "је", "Џон"]
    words_string("Један, два, три, четири, пет, шест") == ["Један", "два", "три", "четири", "пет", "шест"]
    """

def words_string(s):
    """
    Добићете string који садржи речи одвојене зарезима или размацима. Ваш задатак је
    да поделите string на речи и вратите листу речи.

    На пример:
    words_string("Hi, my name is John") == ["Hi", "my", "name", "is", "John"]
    words_string("One, two, three, four, five, six") == ["One", "two", "three", "four", "five", "six"]
    """


def choose_num(x, y):
    """Ова функција узима два позитивна броја x и y, и враћа
    највећи парни цео број који се налази у опсегу [x, y] укључујући.
    Ако не постоји такав број, функција треба да врати -1.

    На пример:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Ова функција узима два позитивна броја к и и и враћа
    највећи паран цео број који је у опсегу [к, и] укључујући. Ако
    не постоји такав број, онда би функција требало да врати -1.

    на пример:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Ова функција прихвата два позитивна броја, x и y, и враћа највећи паран цео број у опсегу [x, y].
    Ако такав број не постоји, функција треба да врати -1.

    Пример:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Ако су дата два позитивна цела броја n и m, задатак је да израчунамо просек
    целих бројева између n и m (укључујући n и m). Заокружимо резултат на најближи
    цео број и претворимо ову вредност у бинарни облик. Ако је n веће од m, вратимо -1.
    Пример:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Дата су вам два позитивна цела броја н и м, а ваш задатак је да израчунате
    просек целих бројева од н до м (укључујући н и м).
    Заокружите одговор на најближи цео број и претворите га у бинарни.
    Ако је н веће од м, вратите -1.
    Пример:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """

def rounded_avg(n, m):
    """Дата су два позитивна цела броја n и m, и ваш задатак је да израчунате
    просек целих бројева између n и m (укључујући n и m).
    Заокружите резултат на најближи цео број и претворите га у бинарни облик.
    Ако је n веће од m, враћа -1.
    Пример:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Дат је x списак позитивних целих бројева, враћа све елементе
    који не садрже парне цифре у облику сортиране листе.

    Напомена: Враћена листа мора бити у растућем редоследу.

    Пример:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Дат је x списак позитивних целих бројева, враћа све елементе
    који не садрже парне цифре у облику сортиране листе.

    Напомена: Враћена листа мора бити у растућем редоследу.

    На пример:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Задата листа позитивних целих бројева к. врати сортирану листу свих
    елементи који немају ниједну парну цифру.

    Напомена: Враћену листу треба сортирати по растућем редоследу.

    на пример:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Ако је дат низ целих бројева, сортирајте целе бројеве од 1 до 9 укључујући 1 и 9,
    затим окрените добијени низ и замените сваки број одговарајућим именом: "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Пример:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

      Ако је низ празан, вратите празан низ:
      arr = []
      return []

      Ако у низу постоји непознат број, игноришите га:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Ако је дат низ целих бројева, сортирајте целе бројеве од 1 до 9,
    затим окрените добијени низ и замените сваки број одговарајућим именом: "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Пример:
    arr = [2, 1, 1, 4, 5, 8, 2, 3]
        -> сортирати arr -> [1, 1, 2, 2, 3, 4, 5, 8]
        -> окренути arr -> [8, 5, 4, 3, 2, 2, 1, 1]
    return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

    Ако је низ празан, вратите празан низ:
    arr = []
    return []

    Ако у низу постоји непознат број, игноришите га:
    arr = [1, -1 , 55]
        -> сортирати arr -> [-1, 1, 55]
        -> окренути arr -> [55, 1, -1]
    return = ['One']
    """

def by_length(arr):
    """
    GАко је дат низ целих бројева, сортирајте целе бројеве од 1 до 9,
    затим окрените добијени низ и замените сваки број одговарајућим именом: "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Пример:
      arr = [2, 1, 1, 4, 5, 8, 2, 3]
            -> sort arr -> [1, 1, 2, 2, 3, 4, 5, 8]
            -> reverse arr -> [8, 5, 4, 3, 2, 2, 1, 1]
      return ["Eight", "Five", "Four", "Three", "Two", "Two", "One", "One"]

     Ако је низ празан, вратите празан низ:
      arr = []
      return []

      Ако у низу постоји непознат број, игноришите га:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Имплементација функције f прихвата n као параметар и
    враћа листу величине n. Елемент на индексу i има вредност i факторијела, ако је i паран,
    иначе враћа збир бројева од 1 до i.
    i почиње од 1.
    i факторијел је производ бројева од 1 до i (1 * 2 * ... * i).
    Пример:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """Реализујте функцију f која прихвата n као параметар
    и враћа list дужине n, такву да је вредност елемента на индексу i факторијел од i ако је i паран
    или збир бројева од 1 до i у супротном.
    i почиње од 1.
    Факторијел од i је производ бројева од 1 до i (1 * 2 * ... * i).
    Пример:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Имплементирати функцију ф која узима н као параметар,
    и враћа листу величине н, тако да је вредност елемента на индексу и факторијел од и ако је и паран
    или збир бројева од 1 до и иначе.
    почињем од 1.
    факторијел од и је множење бројева од 1 до и (1 * 2 * ... * и).
    Пример:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Ако је дат позитиван цео број n, вратите торку која садржи број парних и непарних палиндромских бројева у опсегу (1, n).

    Пример 1:

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

    Пример 2:

        Улаз: 12
        Излаз: (4, 6)
        Објашњење:
        Палиндромски бројеви: 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Од тога четири парна и шест непарних.

    Референце:
        1. 1 <= n <= 10^3
        2. Враћена торка садржи број парних и непарних палиндромских бројева.
    """

def even_odd_palindrome(n):
    """
    Дат цео позитиван број н, вратите тупле који има број парних и непарних
    целобројни палиндроми који спадају у опсег (1, n), укључујући.

    Пример 1:

        Улаз: 3
        Излаз: (1, 2)
        Објашњење:
        Целобројни палиндроми су 1, 2, 3. један од њих је паран, а два су непарна.

    Пример 2:

        Улаз: 12
        Излаз: (4, 6)
        Објашњење:
        Целобројни палиндроми су 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. четири су парна, а 6 непарна.

    Напомена:
        1. 1 <= n <= 10^3
        2. враћени тупле има број парних и непарних целобројних палиндрома.
    """

def even_odd_palindrome(n):
    """
    Дат је позитиван цео број n, вратите пар који садржи број парних и непарних
    целих палиндрома који се налазе у опсегу(1, n), укључујући и n.

    Пример 1:

        Унос: 3
        Излаз: (1, 2)
        Објашњење:
        Цели палиндроми су 1, 2, 3. Један од њих је паран, а два су непарна.

    Пример 2:

        Унос: 12
        Излаз: (4, 6)
        Објашњење:
        Цели палиндроми су 1, 2, 3. Цели палиндроми су 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Четири од њих су парна, а 6 су непарна.

    Напомена:
        1. 1 <= n <= 10^3
        2. Враћени пар садржи број парних и непарних целих палиндрома редом.
    """


def count_nums(arr):
    """
    Напишите функцију count_nums која узима низ целих бројева и враћа
    број елемената чији је збир цифара > 0.
    Ако је број негативан, онда ће његова прва цифра са знаком бити негативна:
    нпр. -123 има цифре са знаком -1, 2, и 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Напишите функцију count_nums која Прима низ целих бројева и враћа број елемената чији је збир цифара већи од 0.
    Ако је број негативан, онда ће прва потписана цифра ће бити негативна са предзнаком:
    Пример: цифре броја -123 са предзнаком су -1, 2, 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Напишите функцију цоунт_нумс која узима низ целих бројева и враћа
    број елемената који има збир цифара > 0.
    Ако је број негативан, онда ће његова прва потписана цифра бити негативна:
    нпр. -123 има потписане цифре -1, 2 и 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Имамо низ 'arr' који садржи N целих бројева: arr[1], arr[2], ..., arr[N].
    Бројеви у низу су насумично распоређени. Твој задатак је да утврдиш
    да ли је могуће сортирати низ у неопадајућем редоследу извршавањем
    следеће операције на датом низу:
        Дозвољено ти је да извршиш операцију померања удесно колико год пута.

    Једна операција померања у десно значи померање свих елемената низа за једну
    позицију удесно. Последњи елемент из низа се помера на
    почетну позицију у низу тј. на индекс 0.

    Ако је могуће добити сортирани низ извођењем горње операције
    онда врати True у супротном врати False.
    Ако је дати низ празан, врати True.

    Напомена: Гарантовано је да дати низ садржи јединствене елементе.

    На пример:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Објашњење: Извођењем 2 операције померања удесно, неопадајући редослед може
                 бити постигнут за дати низ.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Објашњење: Није могуће добити неопадајући редослед за дати
                низ извођењем било ког броја операција померања удесно.

    """

def move_one_ball(arr):
    """Имамо низ 'arr' који садржи N целих бројева: arr[1], arr[2], ..., arr[N].
    Бројеви у низу су насумично распоређени. Задатак је да утврдимо
    да ли је могуће сортирати низ у неопадајућем редоследу извршавањем следеће операције:
        Операција померања удесно може се извршити произвољан број пута.

    Операција померања удесно значи да све елементе низа померамо удесно
    за једну позицију. Последњи елемент низа прелази на почетак, односно на индекс 0.

    Ако се горња операција може извршити да би се постигао сортирани низ, вратите True, иначе вратите False.
    Ако је дати низ празан, вратите True.

    Напомена: Гарантовано је да дати низ садржи јединствене елементе.

    Пример:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Објашњење: Неопадајући редослед датог низа може се постићи извршавањем операције померања удесно 2 пута.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Објашњење: Неопадајући редослед датог низа не може се постићи ниједним бројем померања удесно.

    """

def move_one_ball(arr):
    """Имамо низ 'арр' од Н целих бројева арр[1], арр[2], ..., арр[Н].
    бројеви у низу ће бити насумично поређани. Ваш задатак је да утврдите да ли
    могуће је извођењем добити низ сортиран по неопадајућем редоследу
    следећу операцију на датом низу:
        Дозвољено вам је да извршите операцију померања удесно било који број пута.

    Једна операција померања удесно значи померање свих елемената низа за један
    положај у правом смеру. Последњи елемент низа ће бити премештен у
    почетна позиција у низу, односно 0. индекс.

    Ако је могуће добити сортирани низ извођењем горње операције
    затим врати Труе, иначе врати Фалсе.
    Ако је дати низ празан, вратите Труе.

    Напомена: Гарантовано је да дата листа има јединствене елементе.

    На пример:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Објашњење: Извођењем 2 операције десног померања, неопадајући ред може
                 бити постигнут за дати низ.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Објашњење: Није могуће добити неопадајући редослед за дато
                низ извођењем било ког броја операција померања удесно.

    """


def exchange(lst1, lst2):
    """У овом проблему, реализоваћете функцију која узима два списка бројева,
    и утврђује да ли је могуће извршити размену елемената
    између њих да би lst1 постао списак који садржи само парне бројеве.
    Нема ограничења у броју елемената који се могу заменити између lst1 и lst2.
    Ако је могуће заменити елементе између lst1 и lst2 тако да
    да сви елементи у lst1 буду парни, онда враћа"YES".
    У супротном, враћа "NO".
    На пример:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Претпоставимо да улазне листе нису празне.
    """

def exchange(lst1, lst2):
    """У овом проблему добијамо две листе које садрже бројеве,
    и имплементирамо функцију за одређивање да ли је могуће
    заменити елементе између две листе тако да lst1 садржи
    само парне бројеве.
    Нема ограничења у броју елемената који се могу заменити
    између lst1 и lst2.
    Ако је могуће заменити елементе између lst1 и lst2 тако
    да сви елементи у lst1 буду парни, враћа "YES".
    Ако није, враћа "NO".
    Пример:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Претпоставимо да улазне листе нису празне.
    """

def exchange(lst1, lst2):
    """У овом проблему добијамо две листе које садрже бројеве,
    и имплементирамо функцију за одређивање да ли је могуће
    заменити елементе између две листе тако да lst1 садржи
    само парне бројеве.
    Нема ограничења у броју елемената који се могу заменити
    између lst1 и lst2.
    Ако је могуће заменити елементе између lst1 и lst2 тако
    да сви елементи у lst1 буду парни, враћа "YES".
    Ако није, враћа "NO".
    Пример:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Претпостављамо да улазне листе нису празне.
    """


def histogram(test):
    """За дати низ карактера малих слова одвојених размаком, враћа речник са најчешће појављиваним
    карактерима и њиховим бројем.
    Ако више карактера има исту учесталост, враћа све.

    Пример:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

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

    Пример:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """

def histogram(test):
    """Дат је string који представља размаком одвојена мала слова, враћа речник
    са најчешће појављиваним карактерима и њиховим бројем.
    Ако више карактера има исту учесталост, враћа све.

    Пример:
    histogram('a b c') == {'a': 1, 'b': 1, 'c': 1}
    histogram('a b b a') == {'a': 2, 'b': 2}
    histogram('a b c a b') == {'a': 2, 'b': 2}
    histogram('b b b b a') == {'b': 4}
    histogram('') == {}

    """


def reverse_delete(s,c):
    """Задатак
    Добили смо два низа s и c, морате избрисати све знакове у s који су једнаки било ком карактеру у c
    затим проверите да ли је низ резултата палиндром.
    Низ се назива палиндром ако чита исто уназад и унапред.
    Требало би да вратите тупле који садржи стринг резултата и True/False за проверу.
    Пример
    For s = "abcde", c = "ae", the result should be ('bcd',False)
    For s = "abcdef", c = "b"  the result should be ('acdef',False)
    For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
    """

def reverse_delete(s,c):
    """Задатак
    Добили смо два низа с и ц, морате избрисати све знакове у с који су једнаки било ком карактеру у ц
    затим проверите да ли је низ резултата палиндром.
    Низ се назива палиндром ако чита исто уназад и унапред.
    Требало би да вратите тупле који садржи стринг резултата и Тачно/Нетачно за проверу.
    Пример
    For s = "abcde", c = "ae", the result should be ('bcd',False)
    For s = "abcdef", c = "b"  the result should be ('acdef',False)
    For s = "abcdedcba", c = "ab", the result should be ('cdedc',True)
    """

def reverse_delete(s,c):
    """Задатак
    Дате су нам strings s и c, потребно је уклонити све оне карактере из s који се подударају са карактерима из c
    затим проверити да ли је добијени низ карактера палиндром.
    String се назива палиндромом ако се чита исто с лева на десно и с десна на лево.
    Потребно је вратити пар који садржи добијени низ карактера и True/False вредност за проверу.
    Пример
    For s = "abcde", c = "ae", резултат треба да буде ('bcd',False)
    For s = "abcdef", c = "b"  резултат треба да буде ('acdef',False)
    For s = "abcdedcba", c = "ab", резултат треба да буде ('cdedc',True)
    """


def odd_count(lst):
    """Дата вам је листа string-ова, где сваки string садржи само цифре, вратите листу.
    Сваки елемент i из излаза треба да буде "број непарних елемената у
    string-у i из улаза." где сваки i треба заменити бројем
    непарних цифара у i-том string-у из улаза.

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

def odd_count(lst):
    """Дати листу низова, где се сваки низ састоји само од цифара, вратите листу.
    Сваки елемент и излаза треба да буде „број непарних елемената у
    низ и улаза." при чему све и треба заменити бројем
    непарних цифара у i-том низу улаза.

    >>> odd_count(['1234567'])
    ["број непарних елемената 4n str4ng 4 oд 4nput."]
    >>> odd_count(['3',"11111111"])
    ["број непарних елемената 1n str1ng 1 oд 1nput.",
     "број непарних елемената 8n  str8ng 8 oд 8nput."]
    """

def odd_count(lst):
    """На дату листу низова, где сваки низ садржи само цифре, врати листу.
    Излазна листа треба да има сваки елемент i као „број непарних елемената у i-том улазном низу".
    Овде сваки i треба заменити бројем непарних цифара у i-том улазном низу.

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


def minSubArraySum(nums):
    """
    За дати низ целих бројева nums, пронађите минимални збир било ког непразног подниза
    nums.
    Пример
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Дат низ целих бројева бројева, пронађите минимални збир било ког непразног подниза
    оф нумс.
    Пример
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Дата је листа целих бројева nums, пронађите најмањи збир непразног подниза nums.
    Пример
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Дата је правоугана мрежа бунара. Сваки ред представља појединачни бунар,
    а свака 1 у реду представља једну јединицу воде.
    Сваки бунар има одговарајућу канту која се може користити за вађење воде из њега,
    и све канте имају исти капацитет.
    Ваш задатак је да користите канте како бисте испразнили бунаре.
    Испишите број пута колико је канта потребно спустити.

    Пример 1:
        Input:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Output: 6

    Пример 2:
        Input:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Output: 5

    Пример 3:
        Input:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Output: 0

    Ограничења:
        * сви бунари имају исту дужину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Дата је правоугаона мрежа бунара. Сваки ред представља бунар,
    и сваки ред у броју 1 означава јединицу воде.
    Сваки бунар има канту која се може користити за испумпавање воде, и свака канта има исти капацитет.
    Задатак је испразнити бунаре помоћу канте.
    Излаз је број спуштања канте.

    Пример 1:
        Улаз:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Излаз: 6

    Пример 2:
        Улаз:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Излаз: 5

    Пример 3:
        Улаз:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Излаз: 0

    Ограничења:
        * Дужина сваког бунара је иста
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """

import math

def max_fill(grid, capacity):
    """
    Добијате правоугаону мрежу бунара. Сваки ред представља један бунар,
    а сваки 1 у реду представља једну јединицу воде.
    Сваки бунар има одговарајућу канту која се може користити за извлачење воде из њега,
    а све канте имају исти капацитет.
    Ваш задатак је да користите канте да испразните бунаре.
    Унесите колико пута је потребно да спустите кашике.

    Пример 1:
        Улаз:
            мрежа : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            буцкет_цапацити : 1
        Излаз: 6

    Пример 2:
        Улаз:
            мрежа : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            буцкет_цапацити : 2
        Излаз: 5

    Пример 3:
        Улаз:
            мрежа : [[0,0,0], [0,0,0]]
            капацитет канте: 5
        Излаз: 0

    Ограничења:
        * сви бунари имају исту дужину
        * 1 <= grid.length <= 10^2
        * 1 <= grid[:,1].length <= 10^2
        * grid[i][j] -> 0 | 1
        * 1 <= capacity <= 10
    """


def sort_array(arr):
    """
    У овој Ката, морате сортирати низ ненегативних целих бројева према
    број јединица у њиховој бинарној представи у растућем редоследу.
    За сличан број јединица, сортирајте на основу децималне вредности.

    Мора се имплементирати овако:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

def sort_array(arr):
    """
    У овом задатку, потребно је сортирати низ ненегативних integer-а према
    броју јединица у њиховом бинарном запису у растућем редоследу.
    Ако је број јединица исти, онда сортирамо на основу децималне вредности.

    Мора бити имплементирано на следећи начин:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """

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

    Треба имплементирати на следећи начин:
    >>> sort_array([1, 5, 2, 3, 4]) == [1, 2, 3, 4, 5]
    >>> sort_array([-2, -3, -4, -5, -6]) == [-6, -5, -4, -3, -2]
    >>> sort_array([1, 0, 2, 3, 4]) [0, 1, 2, 3, 4]
    """


def select_words(s, n):
    """За дати string s и природан број n, имплементирајте функцију која враћа
    листу свих речи из string-а s које садрже тачно n сугласника, редом којим се
    појављују у string-у s.
    Ако је string s празан, функција треба да врати празну листу.
    Напомена: можете претпоставити да улазни string садржи само слова и размаке.
    Примери:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """Дати низ s и природан број n, добили сте задатак да имплементирате
    функција која враћа листу свих речи из низа s које садрже тачно
    n сугласнике, како би се ове речи појавиле у низу s.
    Ако је низ s је празан онда функција треба да врати празну листу.
    Напомена: можете претпоставити да улазни низ садржи само слова и размаке.
    Примери:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """

def select_words(s, n):
    """За дати низ s и природни цели број n, потребно је да креирате
    функцију која као одговор враћа листу свих речи из низа s који садржи тачан број
    n консонаната, редоследом којим се они појављују у низу s.
    Уколико је низ s празан, онда функција треба да прикаже одговор као празну листу.
    Напомена: можете претпоставити да улазни низ садржи садржи само слова и размаке.
    Примери:
    select_words("Марија је имала мало јагње", 4) ==> ["мало"]
    select_words("Марија је имала мало јагње", 3) ==> ["Марија", "јагње"]
    select_words("једноставни бели простор", 2) ==> []
    select_words("Здраво свете", 4) ==> ["свете"]
    select_words("Ујка Сем", 3) ==> ["Ујка"]
    """


def get_closest_vowel(word):
    """Датa је реч. Твој задатак је да пронађеш најближи самогласник, који се
    налази између два сугласника с десне стране у речи (разликујући велика и мала слова).

    Самогласници на почетку и крају речи се не рачунају. Ако не постоји такав самогласник
    који испуњава горе наведени услов, врати празан низ.

    Можеш претпоставити да дати низ садржи само енглеске карактере.

    Пример:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Дате вам је реч. Ваш задатак је да пронађете најближи самогласник који стоји између
    два сугласника са десне стране речи (разликује велика и мала слова).

    Самогласници на почетку и на крају се не рачунају. Вратите празан низ ако нисте
    пронађите било који самогласник који испуњава горњи услов.

    Можете претпоставити да дати низ садржи само енглеска слова.

    Примери:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Дата вам је реч. Ваш задатак је да пронађете најближи самогласник који стоји између
    два сугласника са десне стране речи (разликујући велика и мала слова).

    Самогласници на почетку и крају речи се не рачунају. Ако не постоји такав самогласник
    који испуњава горе наведени услов, вратите празан низ.

    Можете претпоставити да дати низ садржи само енглеске карактере.

    Пример:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Дата је листа која садржи два низа. Оба низа садрже само отворене
    заграде '(' или затворене заграде ')'.
    Задатак је проверити да ли је могуће спојити два низа у
    у било ком редоследу тако да се добије добар низ.
    Низ S се сматра добрим ако су све заграде у S
    избалансиране. На пример: низ '(())()' је добар, али низ
    '())' није добар.
    Врати 'Yes' ако постоји начин да се направи добар низ, и врати 'No' у супротном.

    Примери:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Дата је листа која садржи два низа. Оба низа садрже само отворене заграде „(" или затворене заграде „)".
    Задатак је проверити да ли је могуће спојити два низа у било ком редоследу тако да се добије добар низ.
    Низ S се сматра добрим ако су све заграде у S избалансиране. На пример: низ „(())()" је добар, али низ „())" није добар.
    Ако постоји начин да се направи добар низ, вратите „Yes", иначе вратите „No".

    Пример:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Добићете листу од два низа, оба низа се састоје од опен
    само заграде '(' или затворене заграде ')'.
    Ваш посао је да проверите да ли је могуће спојити два низа
    неки ред, да ће резултујући низ бити добар.
    Низ S се сматра добрим ако и само ако су све заграде у S
    су уравнотежени. На пример: стринг '(())()' је добар, док је стринг
    '())' није.
    Вратите „Yes“ ако постоји начин да се направи добар низ, а у супротном врати „No“.

    Примери:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Дат је низ целих бројева arr и позитиван цео број k, врати сортирану листу
    дужине k, која садржи највише k бројева из arr.

    Пример 1:

        Улаз: arr = [-3, -4, 5], k = 3
        Излаз: [-4, -3, 5]

    Пример  2:

        Улаз: arr = [4, -4, 4], k = 2
        Излаз: [4, 4]

    Пример 3:

        Улаз: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Излаз: [2]

    Напомена:
        1. Дужина низа је у опсегу [1, 1000].
        2. Елементи низа су у опсегу [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    За дат низ целих бројева arr и позитиван цео број k, враћа сортирану листу
    дужине k, која садржи највише k бројева из arr.

    Пример 1:

        Улаз: arr = [-3, -4, 5], k = 3
        Излаз: [-4, -3, 5]

    Пример 2:

        Улаз: arr = [4, -4, 4], k = 2
        Излаз: [4, 4]

    Пример 3:

        Улаз: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Излаз: [2]

    Референце:
        1. Дужина низа је у опсегу [1, 1000].
        2. Елементи низа су у опсегу [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Дат низ целих бројева и позитиван цео број к, врати сортирану листу
    дужине к са максималним к бројева у арр.

    Пример 1:

        Улаз: arr = [-3, -4, 5], k = 3
        Излаз: [-4, -3, 5]

    Пример 2:

        Улаз: arr = [4, -4, 4], k = 2
        Излаз: [4, 4]

    Пример 3:

        Улаз: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Излаз: [2]

    Напомена:
        1. Дужина низа ће бити у опсегу од [1, 1000].
        2. Елементи у низу ће бити у опсегу од [-1000, 1000].
        3. 0 <= k <= len(arr)
    """


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

    Примери
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Узимајући у обзир непразну листу целих бројева, вратите збир свих непарних елемената који су на парним позицијама.

    Примери
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

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

    Пример
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """


def add_elements(arr, k):
    """
    Дат је непразан низ целих бројева арр и цео број к, вратите
    збир елемената са највише две цифре из првих к елемената арр.

    Пример:

        Инпут: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Излаз: 24 # sum of 21 + 3

    Ограничења:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Узмимо не празан низ arr који садржи целе бројеве и цео број k,
    вратимо збир елемената у првих k елемената низа arr који имају највише две цифре.

    Пример:

        Улаз: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Излаз: 24 # збир је 21 + 3

    Ограничења:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Дат је непразан array целих бројева arr и integer k. Вратите
    збир елемената са највише две цифре из првих k елемената у arr.

    Пример:

        Улаз: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Излаз: 24 # збир 21 + 3

    Ограничења:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Ако је дат позитиван цео број n, враћа сортирану листу непарних бројева из Колацове секвенце.

    Колацова хипотеза је математичка хипотеза о секвенци бројева дефинисаној на следећи начин:
    Почнимо са било којим позитивним целим бројем n. Затим сваки члан произилази из претходног члана на следећи начин:
    Ако је претходни члан паран, следећи члан је половина претходног члана.
    Ако је претходни члан непаран, следећи члан је три пута претходни члан плус 1.
    Ова хипотеза тврди да без обзира на вредност n, секвенца увек достиже 1.

    Референце:
        1. Collatz(1) је [1].
        2. Враћена листа је сортирана у растућем редоследу.

    Пример:
    get_odd_collatz(5) враћа [1, 5]. # Колацова секвенца за 5 је [5, 16, 8, 4, 2, 1], и непарни бројеви су само 1 и 5.
    """

def get_odd_collatz(n):
    """
    Ако је дат позитиван цео број n, као одговор пружи сортирану листу која има непарне бројеве из Колацове хипотезе.

    Колацова хипотеза је хипотеза у математици која се тиче секвенци дефинисаних
    на следећи начин: почни са било којим позитивним целим бројем n. Тада се сваки члан добија из
    претходног члана на следећи начин: ако је претходни члан паран број, следећи члан је једна половина
    претходног члана. Уколико је претходни члан непаран број, следећи члан је 3 пута претходни
    члан плус 1. Ова хипотеза тврди да, без обзира колика је вредност n, секвенца ће увек бити 1.

    Напомена:
        1. Collatz(1) is [1].
        2. враћена листа је сортирана по растућем редоследу.

    На пример:
    get_odd_collatz(5) returns [1, 5] # Колацова хипотеза за број 5 је [5, 16, 8, 4, 2, 1], тако да су непарни бројеви у овом низу само 1 и 5.
    """

def get_odd_collatz(n):
    """
    Ако је дат позитиван цео број n, вратите сортирану листу непарних бројева из Колацове секвенце.

    Колацова хипотеза је математичка хипотеза о секвенци бројева дефинисаној
    на следећи начин: започни са било којим позитивним целим бројем n. Затим сваки члан произилази из
    претходног члана на следећи начин: ако је претходни члан паран, следећи члан је половина
    претходног члана. Ако је претходни члан непаран, следећи члан је три пута the претходни
    члан плус 1. Ова хипотеза тврди да без обзира на вредност n, секвенца увек достиже 1.

    Напомена:
        1. Collatz(1) је [1].
        2. Враћена листа је сортирана у растућем редоследу.

    На пример:
    get_odd_collatz(5) returns [1, 5] # олацова секвенца за 5 је [5, 16, 8, 4, 2, 1], и непарни бројеви су само 1, и 5.
    """


def valid_date(date):
    """Морате да напишете функцију која потврђује дати низ датума и
    враћа True ако је датум важећи, иначе враћа False.
    Датум је важећи ако су испуњена сва следећа правила:
    1. Низ датума није празан.
    2. Број дана није мањи од 1 или већи од 31 дана за месеце 1,3,5,7,8,10,12. И број дана није мањи од 1 или већи од 30 дана за месеце 4,6,9,11. И, број дана није мањи од 1 или већи од 29 за месец 2.
    3. Месеци не би требало да буду мањи од 1 или већи од 12.
    4. Датум треба да буде у формату: mm-dd-yyyy

    на пример:
    valid_date('03-11-2000') => True

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

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

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

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

def valid_date(date):
    """Морате да напишете функцију која потврђује дати низ датума и
    враћа Trueако је датум валидан, иначе False.
    Датум је валидан ако су испуњена сва следећа правила:
    1. Низ датума не сме бити празан.
    2. Број дана није мањи од 1 или већи од 31 дан за месеце 1,3,5,7,8,10,12. И број дана није мањи од 1 или већи од 30 дана за месеце 4,6,9,11. И, број дана није мањи од 1 или већи од 29 за месец 2.
    3. Месеци не би требало да буду мањи од 1 или већи од 12.
    4. Датум треба да буде у формату: мм-дд-гггг

    на пример:
    valid_date('03-11-2000') => True

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

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

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

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

def valid_date(date):
    """Морате написати функцију која валидира дате string датуме и
    враћа True ако је датум валидан, а иначе False.
    Датум је валидан ако су задовољена сва следећа правила:
    1. string  датума није празан.
    2. Број дана не може бити мањи од 1 или већи од 31 дана за месеце 1,3,5,7,8,10,12. И број дана не може бити мањи од 1 или већи од 30 дана за месеце 4,6,9,11. И број дана не може бити мањи од 1 или већи од 29 за месец 2.
    3. Месеци не могу бити мањи од 1 или већи од 12.
    4. Датум треба да буде у формату: mm-dd-yyyy

    На пример:
    valid_date('03-11-2000') => True

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

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

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

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


def split_words(txt):
    '''
    Раздваја речи у датом тексту помоћу размака и враћа их као листу.
    Ако нема размака, дели их зарезом „," и ако нема ни зареза,
    враћа број малих слова на непарним позицијама у абецеди.
    ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Примери
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
     За задати низ речи, врати листу речи раздвојених размаком, ако размаци не постоје у тексту,
    раздвоји речи помоћу запете ',' ако ни запете не постоје, врати број малих слова на непарним позицијама у
    абецеди, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Примери
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Ако имате низ речи, вратите листу речи подељену на размаке, ако у тексту који не постоје размаци
    треба поделити на зарезе ',' ако не постоје зарези требало би да вратите број малих слова непарног редоследа у
    азбука, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Примери
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Ако је дата листа бројева, враћа да ли је листа у растућем редоследу.
    Ако се појави један или више истих бројева, враћа False.
    Претпоставимо да нема негативних бројева и да су сви бројеви цели.

    Примери
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''

def is_sorted(lst):
    '''
    Дате листу бројева, вратите да ли су сортирани или не
    у растућем редоследу. Ако листа има више од 1 дупликата истог
    број, вратите Фалсе. Претпоставимо да нема негативних бројева и само целих бројева.

    Примери
    is_sorted([5]) ➞ True
    is_sorted([1, 2, 3, 4, 5]) ➞ True
    is_sorted([1, 3, 2, 4, 5]) ➞ False
    is_sorted([1, 2, 3, 4, 5, 6]) ➞ True
    is_sorted([1, 2, 3, 4, 5, 6, 7]) ➞ True
    is_sorted([1, 3, 2, 4, 5, 6, 7]) ➞ False
    is_sorted([1, 2, 2, 3, 3, 4]) ➞ True
    is_sorted([1, 2, 2, 2, 3, 4]) ➞ False
    '''


def intersection(interval1, interval2):
    """Два дата интервала,
    сваки интервал је пар целих бројева. На пример, интервал = (почетак, крај) = (1, 2).
    Дати интервали су затворени, интервал (почетак, крај) садржи
    и почетак и крај.
    За сваки дати интервал претпостављамо да је почетак мањи или једнак крају.
    Задатак је утврдити да ли је дужина пресека два интервала прост број.
    На пример, пресек интервала (1, 3), (2, 4) је (2, 3) и
    његова дужина је 1, што није прост број.
    Ако је дужина пресека прост број, враћа "YES",
    иначе враћа "NO".
    Ако се два интервала не преклапају, враћа "NO".

    [Пример улаз/излаз]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Дата су вам два интервала,
    где је сваки интервал је пар целих бројева. На пример, интервал = (start, end) = (1, 2).
    Дати интервали су затворени, што значи да интервал (start, end)
    укључује и start и end.
    За сваки дати интервал, претпоставља се да је његов start мањи или једнак end.
    Ваш задатак је да одредите да ли је дужина пресека ова два
    интервала прост број.
    На пример, пресек интервала (1, 3), (2, 4) је (2, 3)
    а његова дужина је 1, што није прост број.
    Ако је дужина пресека прост број, враћа "YES",
    у супротном, враћа "NO".
    Ако се два интервала не преклапају, враћа "NO".

    [input/output] примери:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Дата су два интервала,
    сваки интервал је пар целих бројева. На пример, интервал = (почетак, крај) = (1, 2).
    Дати интервали су затворени, интервал (почетак, крај) садржи
    и почетак и крај.
    За сваки дати интервал претпостављамо да је почетак мањи или једнак крају.
    Задатак је утврдити да ли је дужина пресека два интервала прост број.
    На пример, пресек интервала (1, 3), (2, 4) је (2, 3) и
    његова дужина је 1, што није прост број.
    Ако је дужина пресека прост број, враћа „YES",
    иначе враћа „NO".
    Ако се два интервала не преклапају, враћа „NO".

    [Пример улаз/излаз]:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Дат је низ целих бројева arr, потребно је вратити збир апсолутних вредности
    целих бројева, помножен са производом знакова сваког броја.
    Знак је представљен вредностима 1, -1 или 0.
    Напомена: У случају празног низа, вратити None.

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Дат вам је низ целих бројева (arr), и потребно је да вратите
    збир апсолутних вредности елемената низа, помножен производом
    свих знакова сваког броја у низу, представљених са 1, -1 или 0.
    Напомена: функција враћа None за празан arr.

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Дат вам је низ целих бројева и морате га вратити
    збир величина целих бројева помножен производом свих предзнака
    сваког броја у низу, представљеног са 1, -1 или 0.
    Напомена: врати Нема за празно прил.

    Пример:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Дата је мрежа са N редова и N колона (N >= 2) и позитиван цео број k,
    свака ћелија у мрежи садржи вредност. Сваки цео број у опсегу [1, N * N]
    појављује се тачно једном у мрежи.

    Потребно је пронаћи минималну путању дужине k у мрежи. Може се почети
    од било које ћелије, и у сваком кораку може се прећи у било коју суседну ћелију,
    другачије речено, можеш прећи у ћелију која дели границу са тренутном
    ћелијом.
    Имајте на уму да путања дужине к значи посету тачно к ћелији (не
    нужно различиту).
    НЕ СМЕ СЕ напустити мрежа.
    Путања A (дужине k) се сматра мањом од путање B (дужине k) ако
    након направаљене сортиране листе вредности ћелија кроз које A и B пролазе
    (назовимо их lst_A и lst_B), lst_A је лексикографски мања
    од lst_B, другачије речено, постоји индекс са целим бројем i (1 <= i <= k)
    такав да је lst_A[i] < lst_B[i] и за било које j (1 <= j < i) имамо
    lst_A[j] = lst_B[j].
    Гарантовано је да је одговор јединствен.
    Враћа сортирану листу вредности ћелија кроз које пролази минимална путања.

    Примери:

        Унос: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Излаз: [1, 2, 1]

        Унос: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Излаз: [1]
    """

def minPath(grid, k):
    """
    Дата је мрежа са N редова и N колона (N >= 2) и позитиван цео број k,
    свака ћелија у мрежи садржи вредност. Сваки цео број у опсегу [1, N * N]
    појављује се тачно једном у мрежи.

    Потребно је пронаћи минималну путању дужине k у мрежи. Може се почети у било којој ћелији
    и у сваком кораку прећи у суседну ћелију. То значи да се може прећи у ћелију
    која дели ивицу са тренутном ћелијом.
    Путања дужине k значи да се посећује тачно k ћелија (не нужно различитих).
    Не сме се напустити мрежа.
    Путања A дужине k се сматра мањом од путање B ако
    направимо сортирану листу вредности ћелија кроз које A и B пролазе (назовимо их lst_A и lst_B),
    lst_A је лексикографски мања од lst_B. То значи да постоји индекс i (1 <= i <= k),
    за који важи да је lst_A[i] < lst_B[i], и за било које j (1 <= j < i) важи да је lst_A[j] = lst_B[j].
    Гарантовано је да је одговор јединствен.
    Враћа сортирану листу вредности ћелија кроз које пролази минимална путања.

    Пример:

        Улаз: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Излаз: [1, 2, 1]

        Улаз: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Излаз: [1]
    """

def minPath(grid, k):
    """
    Задата мрежа са Н редова и Н колона (Н >= 2) и позитивним целим бројем к,
    свака ћелија мреже садржи вредност. Сваки цео број у опсегу [1, Н * Н]
    инцлусиве се појављује тачно једном на ћелијама мреже.

    Морате пронаћи минималну путању дужине к у мрежи. Можете почети
    из било које ћелије, и у сваком кораку можете да пређете на било коју од суседних ћелија,
    другим речима, можете ићи на ћелије које деле ивицу са вашом тренутном
    ћелија.
    Имајте на уму да путања дужине к значи посету тачно к ћелија (не
    нужно различит).
    НЕ МОЖЕТЕ да изађете из мреже.
    Пут A (of length k) сматра се мањим од пута B (of length k) ако
    након што направимо поређане листе вредности на ћелијама које А и B иду
    кроз (назовимо их lst_A и lst_B), лст_А је лексикографски мање
    од лст_Б, другим речима, постоји целобројни индекс i (1 <= i <= k)
    тако да је lst_A[i] < lst_B[i] било које j (1 <= j < i) имамо
    lst_A[j] = lst_B[j].
    Гарантовано је да је одговор јединствен.
    Вратите уређену листу вредности у ћелијама кроз које пролази минимална путања.

    Примери:

        Улаз: мрежа = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Излаз: [1, 2, 1]

        Улаз: мрежа = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Излаз: [1]
    """


def tri(n):
    """Сви знају за Фибоначијев низ, који математичари проучавају вековима.
    Међутим, мање је познат Трибоначијев низ.
    Трибоначијев низ је дефинисан следећом рекурзивном формулом:
    tri(1) = 3
    tri(n) = 1 + n / 2, ако је n паран број.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), ако је n непаран број.
    Пример:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Ако је дат не-негативан цео број n, треба вратити првих n + 1 Трибоначијевих бројева.
    Пример:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Сви знају Фибоначијев низ који су математичари проучавали
    претходних неколико векова. Међутим, оно са чиме људи нису упознати јесте Трибоначијев низ.
    Трибоначијев низ је дефинисан понављањем:
    tri(1) = 3
    tri(n) = 1 + n / 2, ако је n паран број.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), ако је n непаран број.
    На пример:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Дат вам је не-негативан цео број n, а треба да вратите листу
    првих n + 1 бројева из Трибоначијевог низа.
    Примери:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Сви знају за Фибоначијев низ, дубоко га проучавају математичари
    у последњих неколико векова. Међутим, мање је познат Трибоначијев низ.
    Трибоначијев низ је дефинисан следећом рекурзивном формулом:
    tri(1) = 3
    tri(n) = 1 + n / 2, if n is even.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), if n is odd.
    На пример:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Ако је дат не-негативан цео број n, треба вратити листу
    првих  n + 1 бројева из of the Трибоначијевог низа.
    Примери:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Ако је дат позитиван цео број n, враћа производ непарних цифара.
    Ако су све цифре парне, враћа 0.
    Пример:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Дат је позитиван  integer n, врати производ непарних цифара.
    Врати 0 ако су све цифре парне.
    На пример:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Дат је позитиван цео број n, врати производ непарних цифара.
    Врати 0 ако су све цифре парне.
    На пример:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(string):
    '''
    Направите функцију која прихвата само низ карактера који садржи угласте заграде.
    Ова функција треба да врати True само ако постоји важећи подниз заграда,
    и тај подниз мора да садржи бар једну угнежђену заграду.

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

def is_nested(string):
    '''
    Направите функцију која прихвата само string као input који садржи угласте заграде.
    Ова функција треба да врати True само ако постоји важећи подстринг заграда
    и тај подстринг мора да садржи бар једну угнежђену заграду.

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

def is_nested(string):
    '''
    Напишите функцију која прихвата само string који садржи угласте заграде.
    Функција треба да врати True ако, и само ако, постоји важећа подсеквенца заграда
    у којој је бар једна заграда унутар друге.

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


def sum_squares(lst):
    """Дат вам је списак бројева.
    Треба да вратите суму квадрата бројева у датој листи,
    пре него што сваку вредност у листи заокружите на већи цео број int(Ceiling).
    Примери:
    За lst = [1,2,3] излаз треба да буде 14
    За lst = [1,4,9] излаз треба да буде 98
    За lst = [1,3,5,7] излаз треба да буде 84
    За lst = [1.4,4.2,0] излаз треба да буде 29
    За lst = [-2.4,1,1] излаз треба да буде 6

    """

def sum_squares(lst):
    """Дата је листа бројева.
    Треба вратити збир бројева након што сваки елемент
    у листи заокружимо на цео број и подигнемо на квадрат.
    Пример:
    lst = [1,2,3] тада излаз треба да буде 14.
    lst = [1,4,9] тада излаз треба да буде 98.
    lst = [1,3,5,7] тада излаз треба да буде 84.
    lst = [1.4,4.2,0] тада излаз треба да буде 29.
    lst = [-2.4,1,1] тада излаз треба да буде 6.
    """

def sum_squares(lst):
    """Дата вам је листа бројева.
    Треба да вратите збир бројева на квадрат у датој листи,
    тако што ћете прво заокружити сваки елемент на листи int(Ceiling).
    Примери:
    За lst = [1,2,3] одговор треба да буде 14
    За lst = [1,4,9] одговор треба да буде 98
    За lst = [1,3,5,7] одговор треба да буде 84
    За lst = [1.4,4.2,0] одговор треба да буде 29
    За lst = [-2.4,1,1] одговор треба да буде 6

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Направите функцију која враћа True ако је последњи карактер датог низа слово
    и није део речи.
    У супротном враћа False.
    Напомена: "реч" је група карактера одвојена размаком.

    Пример:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Креирајте функцију која враћа Труе ако је последњи знак
    датог низа је абецедни знак и није
    део речи, а иначе Фалсе.
    Напомена: „реч“ је група знакова одвојених размаком.

    Примери:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''

def check_if_last_char_is_a_letter(txt):
    '''
    Креирај функцију која као одговор даје True ако је последњи карактер
    у датом низу слово, а није
    део речи, а False у супротном случају.
    Напомена: "реч" је група карактера које су одвојене размаком.

    Примери:
    check_if_last_char_is_a_letter("пита од јабука") ➞ False
    check_if_last_char_is_a_letter("пита од јабук а") ➞ True
    check_if_last_char_is_a_letter("пита од јабук а") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Направите функцију која враћа највећи индекс елемента који није већи или једнак
    претходном елементу у датом низу. Ако такав елемент не постоји, вратите -1.
    Дати низ не садржи дупликате.

    Примери:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Направите функцију која враћа највећи индекс елемента који
    није већи или једнак претходном елементу у датом низу. Ако
    такав елемент не постоји, вратите -1. Дати низ не садржи
    дупле вредности.

    Примери:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Креирајте функцију која враћа највећи индекс елемента који
    није већи или једнак елементу који му непосредно претходи. Ако
    не постоји такав елемент онда врати -1. Дати низ неће садржати
    дупле вредности.

    Примери:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Направите функцију која враћа највећи негативан број 'a' и најмањи позитиван број 'b'
    из листе, као пар (a, b).
    Ако нема негативних или позитивних бројева, вратите None.

    Пример:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''

def largest_smallest_integers(lst):
    '''
    Направите функцију која враћа као пар (a, b), где је 'a'
    највећи негативан број, и 'b' најмањи
    позириван број у листи.
    Ако нема негативних или позитивних бројева, вратите None.

    Примери:
    largest_smallest_integers([2, 4, 1, 3, 5, 7]) == (None, 1)
    largest_smallest_integers([]) == (None, None)
    largest_smallest_integers([0]) == (None, None)
    '''


def compare_one(a, b):
    """
    Направите функцију која прихвата целе бројеве, децималне бројеве, или стрингове који представљају
    реалне бројеве, и враћа већу промењиву у датом типу променљиве.
    Враћа None ако су вредности једнаке.
    Напомена: Када је реалан број представљен као стринг, децимална тачка може бити . или ,

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

def compare_one(a, b):
    """
    Прихватите стринг који представља цео број, реалан број или низ карактера,
    и направите функцију која враћа већу променљиву у датом типу променљиве.
    Ако су вредности једнаке, вратите None.
    Напомена: Када је реалан број представљен као низ карактера, децимална тачка може бити . или ,.

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

def compare_one(a, b):
    """
    Креирајте функцију која представља целе бројеве, флоат или низове
    реалне бројеве, и враћа већу променљиву у њеном датом типу променљиве.
    Врати Ноне ако су вредности једнаке.
    Напомена: Ако је реалан број представљен као стринг, плутајући зарез може бити . или ,

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


def is_equal_to_sum_even(n):
    """Процењује да ли се број n може тачно изразити као збир 4 позитивна парна броја
    Пример
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Процени да ли се дати број н може написати као збир тачно 4 позитивна парна броја
    Пример
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """

def is_equal_to_sum_even(n):
    """Процени да ли се дати број n може се написати као збир тачно 4 позитивна парна броја
    Пример
    is_equal_to_sum_even(4) == False
    is_equal_to_sum_even(6) == False
    is_equal_to_sum_even(8) == True
    """


def special_factorial(n):
    """Бразилски факторијел је дефинисан на следећи начин:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    где је n > 0

    Пример:
    >>> special_factorial(4)
    288

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

def special_factorial(n):
    """Бразилски факторијел је дефинисан као:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    где n > 0

    на пример:
    >>> special_factorial(4)
    288

    Функција ће примити цео број као улаз и треба да врати специјални
    факторијел овог целог броја.
    """

def special_factorial(n):
    """Бразилски факторијел је дефинисан на следећи начин:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    where n > 0

    На пример:
    >>> special_factorial(4)
    288

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


def fix_spaces(text):
    """
    За дати стринг text, замените све размаке у њему са доњим цртама,
    а ако стринг има више од 2 узастопна размака,
    онда замените све узастопне размаке са -

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

def fix_spaces(text):
    """
    Уз текст стринга, замените све размаке у њему подвлакама,
    и ако стринг има више од 2 узастопна размака,
    затим замените све узастопне размаке са -

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

def fix_spaces(text):
    """
    Замени све размаке у датом текстуалном низу са доњом цртом,
    и ако у низу постоје 2 или више узастопних размака,
    замени све узастопне размаке са -.

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


def file_name_check(file_name):
    """Креирајте функцију која узима низ који представља име фајла и враћа
    'Yes' ако је име фајла валидно, а враћа 'No' у супротном.
    Име датотеке се сматра валидним ако и само ако су сви следећи услови
    испуњени:
    - Не сме бити више од три цифре ('0'-'9') у имену фајла.
    - Име фајла треба да садржи тачно једну тачку '.'
    - Подниз пре тачке не сме бити празан и мора да почиње са словом
    латиничног алфабета ('a'-'z' и 'A'-'Z').
    - Подниз после тачке треба да буде један од следећих: ['txt', 'exe', 'dll']
    Примери:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (име треба да почиње са словом латиничног алфабета)
    """

def file_name_check(file_name):
    """Креирај функцију која прима име датотеке као низ и враћа „Yes" ако је име датотеке валидно, иначе враћа „No".
    Име датотеке се сматра валидним ако су испуњени сви следећи услови:
    - Име датотеке не сме садржати више од три цифре („0"-„9").
    - Име датотеке мора садржати тачно једну тачку „.".
    - Део пре тачке не сме бити празан и мора почети латиничним словом („a"-„z" и „A"-„Z").
    - Део после тачке мора бити једна од следећих вредности: [„txt", „exe", „dll"]
    Пример:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (Име мора почети латиничним словом)
    """

def file_name_check(file_name):
    """Прима име датотеке као стринг и креира функцију која враћа 'Yes' ако је име датотеке валидно, иначе враћа 'No'.
    Име датотеке се сматра валидним ако су испуњени сви следећи услови:
    - Име датотеке не сме садржати више од три цифре ('0'-'9').
    - Име датотеке мора садржати тачно једну тачку '.'.
    - Део пре тачке не сме бити празан и мора почети латиничним словом ('a'-'z' и 'A'-'Z').
    - Део после тачке мора бити једна од следећих вредности: ['txt', 'exe', 'dll']
    Пример:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (Име мора почети латиничним словом)
    """


def sum_squares(lst):
    """"
    Ова функција прихвата листу целих бројева као улаз. За сваки елемент листе, функција подиже на квадрат елемент ако је индекс
    дељив са 3, и подиже на куб елемент ако је индекс дељив са 4, али није дељив са 3. Функција неће
    променити елементе у листи чији индекси нису дељиви са 3 или 4. Затим функција враћа збир свих елемената.

    Примери:
    For lst = [1,2,3] излаз треба да буде 6
    For lst = []  излаз треба да буде 0
    For lst = [-1,-5,2,-1,-5]  излаз треба да буде -126
    """

def sum_squares(lst):
    """
    Ова функција прихвата листу целих бројева као улаз. За сваки елемент листе, функција подиже на квадрат елемент ако је индекс дељив са 3,
    и подиже на куб елемент ако је индекс дељив са 4, али није дељив са 3. Елементи који нису дељиви ни са 3 ни са 4 остају непромењени.
    Затим функција враћа збир свих елемената.

    Пример:
    lst = [1,2,3] тада излаз треба да буде 6.
    lst = [] тада излаз треба да буде 0.
    lst = [-1,-5,2,-1,-5] тада излаз треба да буде -126.
    """

def sum_squares(lst):
    """"
    Ова функција ће узети листу целих бројева. За све уносе на листи, функција квадрира целобројни унос ако је њен индекс а
    вишеструки од 3 и коцкаће унос целог броја ако је његов индекс вишеструки од 4, а не од 3. Функција неће
    промените уносе на листи чији индекси нису вишекратни од 3 или 4. Функција ће тада вратити збир свих уноса.

    Примери:
    For lst = [1,2,3] the output should be 6
    For lst = []  the output should be 0
    For lst = [-1,-5,2,-1,-5]  the output should be -126
    """


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

    Пример 1:
        Улаз: sentence = "This is a test"
        Излаз: "is"

    Пример 2:
        Улаз: sentence = "lets go for swimming"
        Излаз: "go for"

    Ограничења:
        * 1 <= len(sentence) <= 100
        * реченица садржи само карактере
    """

def words_in_sentence(sentence):
    """
    Дата је реченица која је представљена као string,
    ова реченица садржи више речи одвојених размаком,
    и треба вратити string који садржи оне речи из оригиналне реченице,
    чије су дужине прости бројеви,
    редослед речи у новом string-у мора бити исти као у оригиналној реченици.

    Пример 1:
        Улаз: sentence = "This is a test"
        Излаз: "is"

    Пример 2:
        Улаз: sentence = "lets go for swimming"
        Излаз: "go for"

    Ограничења:
        * 1 <= len(sentence) <= 100
        * реченица садржи само карактере
    """

def words_in_sentence(sentence):
    """
    Дат вам је низ који представља реченицу,
    реченица садржи неке речи одвојене размаком,
    и морате да вратите стринг који садржи речи из оригиналне реченице,
    чије су дужине прости бројеви,
    редослед речи у новом низу треба да буде исти као у оригиналном.

    Пример 1:
        Улаз: реченица = "Ово је тест"
        Излаз: "је"

    Пример 2:
        Улаз: sentence = "lets go for swimming"
        Излаз: "go for"

    Ограничења:
        * 1 <= len(sentence) <= 100
        * реченица садржи само слова
    """


def simplify(x, n):
    """Ваш задатак је да имплементирате функцију која поједностављује израз x * n.
    Функција враћа True ако се x * n може евалуирати као цео број, иначе враћа False.
    x и n су оба текстуалне репрезентације разломака у следећем формату:
    <numerator>/<denominator>, где су бројилац (numerator) и именилац (denominator) позитивни цели бројеви.

    Можете претпоставити да су x и n валидни разломци и да именилац није 0.

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

def simplify(x, n):
    """Ваш задатак је да имплементирате функцију која поједностављује израз
    x * n. Функција враћа True ако се x * n може проценити као цео број, и False
    у супротном. И x и n, су стринг репрезентације разломака и имају следећи формат,
    <бројилац>/<именилац>, где су и бројилац и именилац позитивни цели бројеви.

     Можете претпоставити да су x и n важећи разломци и да немају нулу као именилац.

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

def simplify(x, n):
    """Ваш задатак је да имплементирате функцију која поједностављује израз
    x * n. Функција враћа True ако x * n даје цео број, а False у супротном.
    Обе променљиве x и n су представљене као string  у облику разломка <бројилац>/<именилац>,
    где су и бројилац и именилaц позитивни цели бројеvi.

    Можете претпоставити да су x и n валидни разломци и да немају нулу као именилaц.

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


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

    на пример:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

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

    На пример:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Напишите функцију која сортира дати низ integer-а у растућем редоследу
    према збиру њихових цифара.
    Напомена: ако постоји више елемената са истим збировима цифара,
    поређајте их према њиховом индексу у оригиналној листи.

    На пример:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Напишите функцију која узима низ бројева као улаз и враћа
    број елемената у низу који су већи од 10 и оба
    прва и последња цифра броја су непарне (1, 3, 5, 7, 9).
    на пример:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Прихвати низ бројева као улаз и напиши функцију која враћа број елемената у низу
    који су већи од 10 и чије су обе цифре, прва и последња, непарне (1, 3, 5, 7, 9).
    Пример:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Дат је позитиван цео број n. Потребно је креирати низ целих бројева дужине n.
    За свако i (1 ≤ i ≤ n) вредност a[i] је i * i - i + 1.
    Враћа број тројки (a[i], a[j], a[k]) у низу, где је i < j < k.
    И a[i] + a[j] + a[k] је дељиво са 3.

    Пример:
    Улаз: n = 5
    Излаз: 1
    Објашњење:
    a = [1, 3, 7, 13, 21]
    Једина важећа тројка је (1, 7, 13).
    """

def get_max_triples(n):
    """
    Дат је позитиван цео број n. Потребно је креирати целобројни низ a дужине n.
        За свако i (1 ≤ i ≤ n), вредност a[i] = i * i - i + 1.
        Враћа број тројки (a[i], a[j], a[k]) из низа a где је i < j < k,
    и a[i] + a[j] + a[k] је дељиво са 3.

    Пример :
        Улаз: n = 5
        Излаз: 1
        Објашњење:
        a = [1, 3, 7, 13, 21]
        Једина важећа тројка је (1, 7, 13).
    """

def get_max_triples(n):
    """Дат вам је позитиван integer n. Треба да направите integer низ a дужине n.
        За сваки i (1 ≤ i ≤ n), вредност a[i] = i * i - i + 1.
        Вратите број тројки (a[i], a[j], a[k]) из низа a где i < j < k,
    и a[i] + a[j] + a[k] је дељиво са 3.

    Пример:
        Улаз: n = 5
        Излаз: 1
        Објашњење:
        a = [1, 3, 7, 13, 21]
        Једина важећа тројка је (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    Постоји осам планета у нашем Сунчевом систему: најближа Сунцу је Меркур,
    затим Венера, Земља, Марс, Јупитер, Сатурн, Уран, Нептун.
    Напишите функцију која прима имена две планете као string-ове: planet1 и planet2.
    Функција треба да врати tuple који садржи све планете чије се орбите налазе
    између орбите планете planet1 и орбите планете planet2, сортиране према
    близини Сунцу.
    Функција треба да врати празан tuple ако planet1 или planet2 нису исправна
    имена планета.
    Примери
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Сунчев систем има осам планета: најближа Сунцу је Меркур,
    затим следе Венера, Земља, Марс, Јупитер, Сатурн, Уран, Нептун.
    Напишите функцију која прихвата два имена планета као низ карактера: planet1 и planet2.
    Функција треба да врати n-торку која садржи све планете између орбита planet1 и planet2,
    поређане по редоследу блискости Сунцу.
    Ако planet1 или planet2 нису важећа имена планета, вратите празну n-торку.
    Пример
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    У нашем соларном систему постоји осам планета: најближа Сунцу
    је Меркур, следећа је Венера, затим Земља, Марс, Јупитер, Сатурн,
    Уран, Нептун.
    Напишите функцију која узима два имена планета као низове планет1 и планет2.
    Функција треба да врати тупле који садржи све планете чије су орбите
    који се налази између орбите планете1 и орбите планете2, сортирано по
    близина сунца.
    Функција треба да врати празан тупле ако је планет1 или планет2
    нису тачна имена планета.
    Примери
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''


def sorted_list_sum(lst):
    """Напишите функцију која прихвата списак стрингова као параметар,
    брише стрингове који имају непарне дужине из њега,
    и враћа резултујући списак са сортираним редоследом.
    Списак је увек списак стрингова, а никада низ бројева,
    и може садржати дупликате.
    Редослед списка треба бити растући по дужини сваке речи,
    а треба да вратите списак сортиран по тим правилима.
    Ако две речи имају исту дужину, сортирајте списак абецедно.
    Функција треба да врати списак стрингова у сортираном редоследу.
    Можете претпоставити да све речи имају исту дужину.
    На пример:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

деф сортед_лист_сум(лст):
    """Напишите функцију која прихвата листу стрингова као параметар,
    брише низове који имају непарне дужине из њега,
    и враћа добијену листу са сортираним редоследом,
    Листа је увек листа стрингова а никада низ бројева,
    и може садржати дупликате.
    Редослед листе треба да буде растући по дужини сваке речи, а ви
    треба да врати листу сортирану по том правилу.
    Ако две речи имају исту дужину, сортирајте листу по абецедном реду.
    Функција треба да врати листу стрингова у сортираном редоследу.
    Можете претпоставити да ће све речи имати исту дужину.
    на пример:
    ассерт лист_сорт(["аа", "а", "ааа"]) => ["аа"]
    ассерт лист_сорт(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Напишите функцију која прихвата листу string-ова као параметар,
    брише string-ове који имају непаран број карактера,
    и враћа добијену листу у сортираном редоследу.
    Листа је увек листа string-ова и никад низ бројевa,
    и може садржати дупликате.
    Редослед у листи треба да буде растући према дужини сваке речи, а уколико
    две речи имају исту дужину, листу сортирајте абецедно.
    Функција треба да врати листу string-ова у сортираном редоследу.
    Можете претпоставити да све речи имају исту дужину.
    На пример:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Једноставан програм који треба да врати вредност x ако је n
    прост број, у супротном, треба да врати вредност y.

    Примери:
    за x_or_y(7, 34, 12) == 34
    за x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Једноставан програм који треба да врати вредност x ако је н
    прост број и треба да врати вредност у супротном.

    Примери:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Проста функција која враћа вредност x ако је n
    прост број, иначе враћа y вредност.

    Примери:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Дате листу бројева, вратите збир квадрата бројева
    на листи који су непарни. Занемарите бројеве који су негативни или нису цели бројеви.

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

    Ако је улазна листа празна, вратите 0.
    '''

def double_the_difference(lst):
    '''
    За задати списак бројева, врати збир квадрата бројева
    у листи где су непарни. Игнориши бројеве који су негативни или нису цели бројеви.

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

    Ако је улазна листа празана, врати 0.
    '''

def double_the_difference(lst):
    '''
    Дате листу бројева, вратите збир квадрата бројева
    на листи који су непарни. Занемарите бројеве који су негативни или нису цели бројеви.

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

    Ако је улазна листа празна, вратите се 0.
    '''


def compare(game,guess):
    """Мислим да се сви сећамо оног осећаја када коначно објаве резултат неког дуго очекиваног
    догађаја. Емоције и мисли које имате у таквом моменту
    дефинитивно заслужују да их забележимо и упоредимо.
    Ваш задатак је да утврдите да ли је особа тачно погодила резултате одређеног броја мечева.
    Дата су вам два низа резултата и претпоставки једнаке дужине, где сваки индекс представља један меч.
    Вратите низ исте дужине који показује колико је свака претпоставка била удаљена од резултата. Ако су погодили тачно,
    вредност је 0, а ако нису, вредност је апсолутна разлика између претпоставке и резултата.

    пример:

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

def compare(game,guess):
    """Мислим да се сви сећамо тог осећаја када је резултат неког дуго очекиваног
    догађај је коначно познат. Осећања и мисли које имате у том тренутку су
    свакако вреди забележити и упоредити.
    Ваш задатак је да утврдите да ли је особа тачно погодила резултате више утакмица.
    Дају вам се два низа резултата и погађања једнаке дужине, где сваки индекс показује подударање.
    Врати низ исте дужине који означава колико је удаљено свако нагађање. Ако су тачно погодили,
    вредност је 0, а ако није, вредност је апсолутна разлика између нагађања и резултата.

    пример:

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


def Strongest_Extension(class_name, extensions):
    """Дат је назив класе (карактеран низ) и листа проширења.
    Проширења служе за учитавање додатних класа у класу.
    Снага проширења се рачуна на следећи начин: CAP је број великих слова у имену проширења,
    SM је број малих слова у имену проширења, снага се добија односом CAP - SM.
    Потребно је пронаћи најјаче проширење и вратити карактеран низ у следећем формату:
    ClassName.StrongestExtensionName.
    Ако два проширења имају исту снагу, изаберите оно које се прво појављује на листи.
    На пример, са класом "Slices" и листом проширења ['SErviNGSliCes', 'Cheese', 'StuFfed'],
    'SErviNGSliCes' је најјаче проширење, тако да враћа 'Slices.SErviNGSliCes'
    (снага -1).
    Пример:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Дат је назив класе (карактеран низ) и листа проширења.
    Проширења служе за учитавање додатних класа у класу.
    Снага проширења се рачуна на следећи начин: CAP је број великих слова у имену проширења,
    SM је број малих слова у имену проширења, снага се добија односом CAP - SM.
    Потребно је пронаћи најјаче проширење и вратити карактеран низ у следећем формату:
    ClassName.StrongestExtensionName.
    Ако два проширења имају исту снагу, изаберите оно које се прво појављује на листи.
    На пример, са класом "Slices" и листом проширења ['SErviNGSliCes', 'Cheese', 'StuFfed'],
    'SErviNGSliCes' је најјаче проширење, тако да враћа 'Slices.SErviNGSliCes'
    (снага -1).
    Пример:
    Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Биће вам дато име класе (стринг) и листа екстензија.
    Екстензије треба да се користе за учитавање додатних класа у класу.
    Снага екстензија се рачуна на следећи начин: Нека је CAP број великих слова
    у називу екстензије, SM број малих слова
    у називу екстензије, јачина је дата разломком CAP - SM.
    Требало би да пронађете најјачу екстензију и вратите стринг у
    формату: ClassName.StrongestExtensionName.
    Ако постоје две или више екстензија исте снаге, требало би да
    изаберете ону која је прва на листи.
    На пример, ако вам је дат "Slices" као класа и листа
    екстензија: ['SErviNGSliCes', 'Cheese', 'StuFfed'] онда би требало да
    врати 'Slices.SErviNGSliCes' пошто је 'SErviNGSliCes' најјача екстензија
    (њена јачина је -1).
    Пример:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """


def cycpattern_check(a , b):
    """Дати су вам 2 речи. Треба да вратите True ако је друга реч или било која од њених ротација substring у првој речи.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True
    """

def cycpattern_check(a , b):
    """Дате су вам 2 речи. Морате да вратите True ако је друга реч или било која од њених ротација подниз у првој речи
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Дате су вам 2 речи. Морате да вратите Тачно ако је друга реч или било која од њених ротација подниз у првој речи
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Дат је цео број. Вратите торку која садржи број парних и непарних цифара, респективно..

     Пример:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Дат је цео број. вратите тупле који има број парних и непарних цифара респективно.

     Пример:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Дат цео број. вратите tuple који има број парних и непарних цифара.

     Пример:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Дат позитиван цео број, добијте његов еквивалент римског броја као низ,
    и вратите га малим словима.
    Ограничења: 1 <= број <= 1000

    Примери:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Дат је позитиван integer, нађи његов еквивалент у римским бројевима као string
    и врати га у малим словима.
    Ограничења: 1 <= број <= 1000

    Примери:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Ако је дат позитиван цео број, враћа одговарајуће римске цифре
    и враћа их у малим словима.
    Ограничење: 1 <= num <= 1000

    Пример:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Дате су дужине три стране троугла. Враћа True ако три
    стране чине правоугли троугао, иначе враћа False.
    Правоугли троугао је троугао који има један прав угао или угао од
    90 степени.
    Пример:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Ако су дате дужине три стране троугла и те три стране чине правоугли троугао, враћа True,
    иначе враћа False.
    Правоугли троугао је троугао који има један прав угао или угао од 90 степени.
    Пример:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Дате су дужине три стране троугла. Врати Труе ако су три
    странице чине правоугли троугао, иначе нетачно.
    Правоугли троугао је троугао у коме је један угао правоугао или
    90 степени.
    Пример:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Напишите функцију која прихвата листу низова.
    Листа садржи различите речи. Вратите реч са максималним бројем
    јединствених знакова. Ако више стрингова има максималан број јединствених
    знакова, вратите онај који је први у лексикографском редоследу.

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

def find_max(words):
    """Напишите функцију која прихвата листу низа карактера.
    Листа садржи различите речи. Вратите реч са максималним бројем
    јединствених карактера. Ако више низова има максималан број јединствених
    карактера, врати онај који је први у лексикографском реду.

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

def find_max(words):
    """Напишите функцију која прихвата листу string-ова.
    Листа садржи различите речи. Вратите реч са максималним бројем
    јединствених карактера. Ако више string-ова има исти број јединствених
    карактера, вратите онај који први долази у лексикографском поретку.

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


def eat(number, need, remaining):
    """
    Ви сте гладни зец који је већ појео одређену количину шаргарепе,
    али сада морате појести више шаргарепе да бисте завршили дневни оброк.
    Треба да вратите низ [ укупан број поједених шаргарепа након оброка,
                                    број преосталих шаргарепа након оброка ].
    Ако преостале шаргарепе нису довољне, појешћете све преостале шаргарепе, али ћете и даље остати гладни.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Променљиве:
    @number : цео број
        број шаргарепа које су до сада поједене.
    @need : цео број
        број шаргарепа које треба да поједеш.
    @remaining : цео број
        број преосталих шаргарепа које постоје на залихама

    Услови:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Забави се :)
    """

def eat(number, need, remaining):
    """
    Ви сте гладни зец који је већ појео одређену количину шаргарепе,
    али сада морате појести више шаргарепе да бисте завршили дневни оброк.
    Треба да вратите низ [ укупан број поједених шаргарепа након оброка,
                           број преосталих шаргарепа након оброка ].
    Ако преостале шаргарепе нису довољне, појешћете све преостале шаргарепе, али ћете и даље остати гладни.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Променљиве:
    @number : цео број
        Број шаргарепа које су до сада поједене.
    @need : цео број
        Потребан број шаргарепа.
    @remaining : цео број
        Број шаргарепа на залихама

    Услови:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Пријатно :)
    """

def eat(number, need, remaining):
    """
    Ти си гладан зец, а већ си појео одређени број шаргарепе,
    али сада морате да једете више шаргарепе да бисте завршили дневне оброке.
    требало би да вратите низ од [ укупан број поједених шаргарепа после оброка,
                                    број шаргарепе преосталих након оброка]
    ако нема довољно преосталих шаргарепа, појешћете све преостале шаргарепе, али ћете и даље бити гладни.

    Пример:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Променљиве:
    @number : integer
        број шаргарепе коју сте појели.
    @need : integer
        број шаргарепе коју треба да једете.
    @remaining : integer
        број преосталих шаргарепа које постоје на залихама

    Ограничити:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    забавите се :)
    """


def do_algebra(operator, operand):
    """
    Дате су две листе: operator и operand. Прва листа садржи основне алгебарске операције,
    а друга листа је листа целих бројева. Користите дате листе да изградите алгебарски
    израз и вратите резултат тог израза.

    Основне алгебарске операције:
    Сабирање ( + )
    Одузимање ( - )
    Множење ( * )
    Целобројно дељење ( // )
    Степеновање ( ** )

    Пример:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Напомена:
        Дужина листе operator једнака је дужини листе operand умањеној за један.
        Operand је листа не-негативних целих бројева.
        Листа operator садржи најмање један оператор, а листа operand садржи најмање два операнда.

    """

def do_algebra(operator, operand):
    """
    Дате су две листе оператор и операнд. Прва листа има основне алгебарске операције, и
    друга листа је листа целих бројева. Користите две дате листе за изградњу алгебрике
    израз и врати процену овог израза.

    Основне алгебарске операције:
    Сабирање ( + )
    Одузимање ( - )
    множење ( * )
    Спратна подела ( // )
    Експоненцијација (**)

    Пример:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Напомена:
        Дужина листе оператора је једнака дужини листе операнада минус један.
        Операнд је листа целих бројева који нису негативни.
        Листа оператора има најмање један оператор, а листа операнда има најмање два операнда.

    """

def do_algebra(operator, operand):
    """
    Дате су две листе: operator и operand. Прва листа садржи основне алгебарске операције,
    а друга листа садржи листу целих бројева. Користите ове две листе за креирање алгебарског израза
    и вратите резултат евалуације израза.

    Основне алгебарске операције:
    Сабирање ( + )
    Одузимање ( - )
    Множење ( * )
    Дељење ( // )
    Степеновање ( ** )

    Пример:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Напомена:
    Дужина листе operator је за један мања од дужине листе operand.
    Листа operand се састоји од ненегативних целих бројева.
    Листа operator садржи најмање један оператор, а листа operand садржи најмање два операнда.

    """


def solve(s):
    """Дат је низ s.
    Ако је s[i] карактер, претвори мала слова у велика или обрнуто,
    ако није, остави га непромењеним.
    Ако низ не садржи карактере, окрени низ.
    Функција треба да врати резултујући низ.
    Пример
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Дат вам је низ s.
    ако је с[и] слово, преокренути његово велико и велико од доњег у горње или обрнуто,
    иначе нека остане онаква каква јесте.
    Ако стринг не садржи слова, обрните низ.
    Функција треба да врати резултовани стринг.
    Примери
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Дат је стринг s.
    Ако је s[i] карактер, претвори мала слова у велика или обрнуто,
    ако није, остави га непромењеним.
    Ако стринг не садржи карактере, окрени стринг.
    Функција треба да врати резултујући стринг.
    Примери
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """