def encrypt(s):
    """Az encrypt függvény egy karakterláncot kap paraméterként, és
    az ábécében való eltolással titkosított karakterláncot ad vissza.
    Az ábécében a karakterek két hellyel kerülnek eltolásra.
    Például:
    encrypt('hi') a visszaadott érték 'lm'
    encrypt('asdfghjkl') a visszaadott érték 'ewhjklnop'
    encrypt('gf') a visszaadott érték 'kj'
    encrypt('et') a visszaadott érték 'ix'
    """

def encrypt(s):
    """Hozzon létre egy függvénytitkosítást, amely egy karakterláncot vesz argumentumként és
    egy elforgatott ábécével titkosított karakterláncot ad vissza.
    Az ábécét úgy kell elforgatni, hogy a betűk
    tolja le kettővel szorozva két helyre.
    Például:
    encrypt('hi') returns 'lm'
    encrypt('asdfghjkl') returns 'ewhjklnop'
    encrypt('gf') returns 'kj'
    encrypt('et') returns 'ix'
    """

def titkosítás(s):
    """Hozzon létre titkosító függvényt, amely karakterláncot vesz argumentumként, és
    Egy az ábécé elforgatásával titkosított karakterláncot ad vissza.
    Az ábécét úgy kell forgatni, hogy a betűk
    Tolja le a betűket 4 helyet lefelé.
    Például:
    Az titkosítás('hi') eredménye 'lm'
    Az titkosítás('asdfghjkl') eredménye 'ewhjklnop'
    Az titkosítás('gf') eredménye "kj"
    Az titkosítás('et') eredménye "ix"
    """


def next_smallest(lst):
    """
    Egy egész számokból álló listát kaptál.
    Írj egy next_smallest() nevű függvényt, amely visszaadja a lista 2. legkisebb elemét.
    Ha nincs ilyen elem, térjen vissza None értékkel.

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

def next_smallest(lst):
    """
    Kap egy listát az egész számokról.
    Írjon egy next_smallest() függvényt, amely a lista 2. legkisebb elemét adja vissza.
    Return None (Nincs visszaadás), ha nincs ilyen elem.

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

def next_smallest(lst):
    """
    Megkapja az egész számok listáját.
    Írjon egy next_smallest() függvényt, amely a lista 2. legkisebb elemét adja vissza.
    Return None, ha nincs ilyen elem.

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


def is_bored(S):
    """
    Egy szavakból álló karakterláncot kap, és az a feladata, hogy megszámolja az
    unalom eseteit. Az unalom olyan mondat, amely az "I" szóval kezdődik.
    A mondatokat a '.', '?' vagy '!' karakterek választják el egymástól.

    Például:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Kapunk egy szöveget, és a feladat, hogy megszámold az
    unalmokat. Az unalom egy olyan mondat, amely 'I' szóval kezdődik..
    A mondatokat '.', '?' vagy '!' jelzők határolják.

    Például:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue. The sun is shining. I love this weather")
    1
    """

def is_bored(S):
    """
    Kapsz egy szósort, és az Ön feladata, hogy megszámolja a számot
    az unalom. Az unalom olyan mondat, amely az "én" szóval kezdődik.
    A mondatokat ".", "?" vagy "!" határolja.

    Például:
    >>> is_bored("Hello world")
    0
    >>> is_bored("The sky is blue.  The sun is shining.  I love this weather")
    1
    """


def any_int(x, y, z):
    '''
    Hozzon létre egy függvényt, amely 3 számot vesz fel.
    Igaz értéket ad vissza, ha az egyik szám egyenlő a másik kettő összegével, és minden szám egész szám.
    Minden más esetben hamis értéket ad vissza.

    Példák
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''

def any_int(x, y, z):
    '''
    Hozzon létre egy függvényt, amely 3 számot vesz.
    Igazat ad vissza, ha ezen három szám egyike egyenlő a fennmaradó két szám összegével, és mindhárom szám egész szám.
    Hamisat ad vissza minden más esetben.

    Példa
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

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

def any_int(x, y, z):
    '''
    Hozz létre egy olyan függvényt, amely bemenetként 3 számot fogad el.
    'True'-t ad vissza, ha a számok bármelyik egyenlő a másik két szám összegével, és minden szám egész szám.
    Minden más esetben 'False'-ot ad vissza.

    Példák
    any_int(5, 2, 7) ➞ True

    any_int(3, 2, 2) ➞ False

    any_int(3, -2, 1) ➞ True

    any_int(3.6, -2.2, 2) ➞ False

    '''


def encode(message):
    """
    Írjon egy függvényt, amely egy üzenetet vesz be, és úgy kódolja,
    hogy megcseréli az összes betű kis- és nagybetűs formáját,
    valamint minden magánhangzót a következő két helyen szereplő
    betűvel helyettesít az angol ábécében.
    Feltételezze, hogy csak betűk lesznek az üzenetben.

    Példák:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Írjon egy függvényt, amely üzenetet fogad, és kódolja
    úgy, hogy felcseréli az összes betű kis- és nagybetűjét, helyettesíti az összes magánhangzót
    A magánhangzókat A 2 helyet követő betűkkel helyettesíti az angol ábécében.
    Tegyük fel, hogy csak betűket használ.

    Példák:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """

def encode(message):
    """
    Írjon egy függvényt, amely fogad egy üzenetet, és kódolja azt
    úgy, hogy felcseréli az összes betűt, és kicseréli az összes magánhangzót
    az üzenet a betűvel, amely 2 hellyel előtte jelenik meg
    magánhangzó az angol ábécében.
    Tételezzük fel, hogy csak betűk.

    Példák:
    >>> encode('test')
    'TGST'
    >>> encode('This is a message')
    'tHKS KS C MGSSCGG'
    """


def skjkasdkd(lst):
    """Megkapja az egész számok listáját.
    Meg kell találnia a legnagyobb prímértéket, és vissza kell adnia a számjegyeinek összegét.

    Példák:
    For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
    For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output should be 25
    For lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] the output should be 13
    For lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] the output should be 11
    For lst = [0,81,12,3,1,21] the output should be 3
    For lst = [0,8,1,2,1,7] the output should be 7
    """

def skjkasdkd(lst):
    """Adott egy egész számokat tartalmazó lista.
    Találd meg a legnagyobb prímszámot, és add vissza a számjegyeinek az összegét.

    Példák:
    lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] a kimenet 10
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] a kimenet 25
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] a kimenet 13
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] a kimenet 11
    lst = [0,81,12,3,1,21] a kimenet 3
    lst = [0,8,1,2,1,7] a kimenet 7
    """

def skjkasdkd(lst):
    """Kapsz egy listát az egész számokról.
    Meg kell találnia a legnagyobb elsődleges értéket, és vissza kell adnia a számjegyek összegét.

    Példák:
    lst = [0,3,2,1,3,5,5,7,4,5,5,5,2,181,32,4,32,3,32,32,324,4,3] esetén a kimenetnek 10-nek kell lennie
    lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] esetén a kimenetnek 25-nek kell lennie
    lst = [1,3,1,32,5107,34,83278,109,163,23,2323,32,30,1,9,3] esetén a kimenetnek 13-nak kell lennie
    lst = [0,724,32,71,99,32,6,0,5,91,83,0,5,6] esetén a kimenetnek 11-nek kell lennie
    lst = [0,81,12,3,1,21] esetén a kimenetnek 3-nak kell lennie
    lst = [0,8,1,2,1,7] esetén a kimenetnek 7-nek kell lennie
    """


def check_dict_case(dict):
    """
    Adott szótár esetén adja vissza az True értéket, ha minden kulcs kisbetűs sztring, vagy minden kulcs nagybetűs sztring.
    különben False értéket ad vissza.
    A függvénynek False értéket kell visszaadnia, ha az adott szótár üres.
    Példák:
    check_dict_case({"a":"apple", "b":"banana"}) True értéket kell visszaadnia.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) False értéket kell visszaadnia.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) False értéket kell visszaadnia.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) False értéket kell visszaadnia.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) True értéket kell visszaadnia.
    """

def check_dict_case(dict):
    """
    Adott egy szótár, adjon True értéket, ha az összes kulcs karakterlánc kisbetűs, vagy az összes kulcs karakterlánc nagybetűs, ellenkező esetben adjon False értéket vissza.
    A függvénynek False-t kell visszaadnia, ha az adott szótár üres.
    Példák:
    check_dict_case({"a":"apple", "b":"banana"}) should return True.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) should return False.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) should return False.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"}) should return False.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) should return True.
    """

def check_dict_case(dict):
    """
    Egy szótár esetében, True értéket adjon vissza, ha a megadott szótár összes kulcsa vagy mind kisbetűs, vagy mind nagybetűs karakterlánc.
    Egyéb esetben False értéket adjon vissza.
    Ha a megadott szótár üres, a függvénynek False értéket kell visszaadnia.
    Példa:
    check_dict_case({"a":"apple", "b":"banana"}) True értéket kell visszaadnia.
    check_dict_case({"a":"apple", "A":"banana", "B":"banana"}) False értéket kell visszaadnia.
    check_dict_case({"a":"apple", 8:"banana", "a":"apple"}) False értéket kell visszaadnia.
    check_dict_case({"Name":"John", "Age":"36", "City":"Houston"})False értéket kell visszaadnia.
    check_dict_case({"STATE":"NC", "ZIP":"12345" }) True értéket kell visszaadnia.
    """


def count_up_to(n):
    """Készíts egy olyan függvényt, amelynek a bemenete egy nem negatív egész szám, és amely
    annak az első n egész számnak a tömbjét adja vissza, amelyek prímszámok, és kisebbek, mint n.
    Például:
    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):
    """Valósítson meg egy függvényt, amely egy nem negatív egész számot vesz fel, és az első n tömbjét adja vissza
    olyan egész számok, amelyek prímszámok és kisebbek, mint n.
    például:
    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):
    """Implementáljon egy függvényt, amely nem negatív egész számot vesz fel, és az első n tömbjét adja vissza
    egész számok, amelyek prímszámok és kisebbek, mint n.
    például:
    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):
    """Egészítsd ki a függvényt, amely két egész számot vesz be, és visszaadja
    azok egyes helyiértékein lévő számjegyeinek szorzatát.
    Feltételezzük, hogy a bemenet mindig érvényes.
    Példák:
    multiply(148, 412) esetén az eredmény 16.
    multiply(19, 28) esetén az eredmény 72.
    multiply(2020, 1851) esetén az eredmény 0.
    multiply(14,-15) esetén az eredmény 20.
    """

def multiply(a, b):
    """Fejezze be azt a függvényt, amely két egész számot vesz fel, és visszaadja
    az egységszámjegyek szorzata.
    Tegyük fel, hogy a bemenet mindig érvényes.
    Példák:
    multiply(148, 412)függvénynek 16-ot kell visszaadnia.
    multiply(19, 28)  függvénynek 72-t kell visszaadnia.
    multiply(2020, 1851) 0-t kell visszaadnia.
    multiply(14,-15)  függvénynek 20-at kell visszaadnia.
    """

def multiply(a, b):
    """Fejezze be a függvényt, amely két egész számot vesz fel, és visszatér
    egységszámjegyeik szorzata.
    Tegyük fel, hogy a bemenet mindig érvényes.
    Példák:
    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 count_upper(s):
    """
    Adott s karakterlánc, számolja meg a nagybetűs magánhangzókat a páros indexeken.

    Példa:
    count_upper('aBCdEf') visszaadja 1
    count_upper('abcdefg') visszaadja 0
    count_upper('dBBE') visszaadja 0
    """

def count_upper(s):
    """
    Adott egy s karakterlánc, és meg kell számolni a nagybetűs magánhangzókat a páros indexeken.

    Példa:
    count_upper('aBCdEf') visszaadja az 1-et
    count_upper('abcdefg') visszaadja az 0-t
    count_upper('dBBE') visszaadja az 0-t
    """

def count_upper(s):
    """
    Adott egy s karakterlánc. Számold meg a nagybetűs magánhangzókat a páros indexekben.

    Például:
    count_upper('aBCdEf') returns 1
    count_upper('abcdefg') returns 0
    count_upper('dBBE') returns 0
    """


def closest_integer(value):
    '''
    Készíts egy olyan függvényt, amely egy számot (sztringként) kap bemenetként,
    és visszaadja a hozzá legközelebbi egész számot. Ha a szám két egész számtól
    egyenlő távolságra van, akkor a nulla felé távolabbi egész számra kerekít.

    Példák:
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Megjegyzés:
    A nulla felé történő kerekítés azt jelenti, hogy ha a megadott szám
    két egész számtól egyenlő távolságra van, akkor azt az egész számot kell
    visszaadni, amelyik távolabb van a nullától. Például a closest_integer("14.5")
    15-öt kell, hogy visszaadjon, és a closest_integer("-14.5") -15-öt.
    '''

def closest_integer(value):
    '''
    Hozzon létre egy függvényt, amely egy számot reprezentáló értéket (karakterláncot) vesz fel
    és a hozzá legközelebbi egész számot adja vissza. Ha a szám egyenlő távolságra van
    két egész számból kerekítse le nullától.

    Példák
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Jegyzet:
    A nulláról lekerekítés azt jelenti, hogy ha az adott szám egyenlő távolságra van
    két egész számból azt az egyet kell visszaadnia, amelyik a
    legtávolabb a nullától. Például a closest_integer("14.5") kellene
    return 15 és a closest_integer("-14.5") -15 értékkel tér vissza.
    '''

def closest_integer(value):
    '''
    Hozzon létre egy függvényt, amely egy számot képviselő értéket (karakterláncot) vesz fel
    , és a hozzá legközelebbi egész számot adja eredményül. Ha a szám egyenlő távolságra van
    Két egész számból kerekítse el nullától.

    Példák
    >>> closest_integer("10")
    10
    >>> closest_integer("15.3")
    15

    Jegyzet:
    A nullától való elkerekítés azt jelenti, hogy ha az adott szám egyenlő távolságra van
    Két egész számból azt kell visszaadnia, amelyik a
    legtávolabb a nullától. Például a closest_integer ("14.5")
    A visszatérési érték 15, a closest_integer("-14,5") pedig -15.
    '''


def make_a_pile(n):
    """
    Adott egy pozitív egész szám n. Egy n szintből álló kőhalmot kell készíteni.
    Az első szint n kőböl áll.
    A következő szinten a kövek száma:
        - a következő páratlan szám, ha n páratlan;
        - a következő páros szám, ha n páros.
    Add vissza egy listában a kövek számát minden egyes szinten, ahol az i indexű
    elem az (i+1) szint köveinek a száma.

    Példák:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Adott egy pozitív n egész szám, akkor egy halom n szintű köveket kell készítenie.
    Az első szinten n kövek vannak.
    A kövek száma a következő szinten:
        - a következő páratlan szám, ha n páratlan.
        - a következő páros szám, ha n páros.
    A lista egyes szintjein lévő kövek számát adja eredményül, ahol az elem az indexben
    i a szintek köveinek számát jelöli (i+1).

    Példák:
    >>> make_a_pile(3)
    [3, 5, 7]
    """

def make_a_pile(n):
    """
    Adott egy n pozitív egész szám, akkor egy halom n szintű kőből kell állnia.
    Az első szinten n kő van.
    A következő szinten lévő kövek száma:
        - a következő páratlan szám, ha n páratlan.
        - a következő páros szám, ha n páros.
    Adja vissza a kövek számát a listában minden szinten, ahol az elem az indexben van
    i a szinten lévő kövek számát jelenti (i+1).

    Példák:
    >>> make_a_pile(3)
    [3, 5, 7]
    """


def words_string(s):
    """
    Kap egy vesszővel vagy szóközzel elválasztott szavakból álló karakterláncot.
    Az Ön feladata a karakterlánc szavakra bontása és a szavak listájának visszaadása.

    Példa:
    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):
    """
    Kapsz egy szófüzetről, vesszővel vagy szóközzel elválasztva. Az Ön feladata:
    a karakterláncot szavakra kell felosztani és a szavak tömbjének visszaadásához.

    Például:
    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):
    """
    Egy sor szót fog kapni, vesszővel vagy szóközzel elválasztva. A te feladatod az
    hogy a karakterláncot szavakra bontsa, és visszaadja a szavak tömbjét.

    Például:
    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):
    """Ez a függvény két pozitív számot, x-et és y-t vesz, és visszaadja a legnagyobb páros egész számot az [x, y] tartományban.
    Ha ilyen szám nem létezik, a függvénynek -1-et kell visszaadnia.

    Példa:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Ez a függvény két pozitív x és y számot vesz fel, és visszaadja a
    A legnagyobb páros egész szám, amely az [x, y] tartományba esik. Ha
    Nincs ilyen szám, akkor a függvénynek -1-et kell visszaadnia.

    Például:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """

def choose_num(x, y):
    """Ez a függvény két pozitív x és y számot vesz fel, és visszaadja a
    a legnagyobb páros egész szám, amely az [x, y] tartományba esik. Ha
    nincs ilyen szám, akkor a függvénynek -1-et kell visszaadnia.

    Például:
    choose_num(12, 15) = 14
    choose_num(13, 12) = -1
    """


def rounded_avg(n, m):
    """Bemenetként adott két pozitív egész szám: n és m, és a feladatod az, hogy kiszámítsd
    n-től m-ig (az n-et és az m-et is beleértve) az egész számok átlagát.
    A választ kerekítsd a legközelebbi egész számra, és azt konvertáld át bináris értékre.
    Ha n nagyobb, mint m, -1-et adj vissza.
    Példa:
    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):
    """ Két pozitív egész számot, n és m-et kap, és a feladata, hogy kiszámítsa
    az n-től m-ig terjedő egész számok (beleértve n-et és m-et is) átlagát.
    Kerekítse az eredményt a legközelebbi egész számra, majd alakítsa bináris számra.
    Ha n nagyobb, mint m, adja vissza az -1 értéket.
    Példa:
    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):
    """Két pozitív egész számot kapsz n és m, és a feladatod az, hogy kiszámítsd a
    Az N-től M-ig terjedő egész számok átlaga (beleértve az N és M számokat is).
    Kerekítse a választ a legközelebbi egész számra, és alakítsa át binárissá.
    Ha n nagyobb, mint m, akkor adja vissza a -1 értéket.
    Példa:
    rounded_avg(1, 5) => "0b11"
    rounded_avg(7, 5) => -1
    rounded_avg(10, 20) => "0b1111"
    rounded_avg(20, 33) => "0b11010"
    """


def unique_digits(x):
    """Adott pozitív egész számok listájára x, térjen vissza egy rendezett listával,
    amely tartalmazza azokat az elemeket, amelyek nem tartalmaznak páros számjegyet.

    Megjegyzés: A visszatérő listát növekvő sorrendben kell rendezni.

    Például:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Adott egy x pozitív egész számok listája. visszaküldi az összes rendezett listáját
    olyan elemek, amelyeknek nincs páros számjegye.

    Megjegyzés: A visszaküldött listát növekvő sorrendbe kell rendezni.

    Például:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """

def unique_digits(x):
    """Adott egy pozitív egész számok listája x. visszaadja az összes rendezett listáját
    olyan elemek, amelyeknek nincs páros számjegye.

    Megjegyzés: A visszaküldött listát növekvő sorrendbe kell rendezni.

    Például:
    >>> unique_digits([15, 33, 1422, 1])
    [1, 15, 33]
    >>> unique_digits([152, 323, 1422, 10])
    []
    """


def by_length(arr):
    """
    Egész számok tömbje esetén rendezze az 1 és 9 közötti egész számokat,
    Fordítsa meg az eredményül kapott tömböt, majd cserélje le az egyes számjegyeket a megfelelő nevére
    "Egy", "Kettő", "Három", "Négy", "Öt", "Hat", "Hét", "Nyolc", "Kilenc".

    Például:
         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"]

      Ha a tömb üres, adjon vissza egy üres tömböt:
      arr = []
      return []

      Ha a tömb furcsa számot tartalmaz, hagyja figyelmen kívül:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Adott egész számok tömbje, rendezze azokat az egész számokat, amelyek 1 és 9 között vannak, beleértve,
    fordítsa meg az eredményül kapott tömböt, majd cserélje ki az egyes számjegyeket a megfelelő nevükre
    "Egy", "Kettő", "Három", "Négy", "Öt", "Hat", "Hét", "Nyolc", "Kilenc".

    Például:
      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"]

      If the array is empty, return an empty array:
      arr = []
      return []

      If the array has any strange number ignore it:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """

def by_length(arr):
    """
    Adott egész számok tömbje, rendezze azokat az egész számokat, amelyek 1 és 9 között vannak, beleértve,
    fordítsa meg az eredményül kapott tömböt, majd cserélje ki az egyes számjegyeket a megfelelő nevükre
    "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine".

    Például:
      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"]

      Ha a tömb üres, adjon vissza egy üres tömböt:
      arr = []
      return []

      Ha a tömbben furcsa szám van, hagyja figyelmen kívül:
      arr = [1, -1 , 55]
            -> sort arr -> [-1, 1, 55]
            -> reverse arr -> [55, 1, -1]
      return = ['One']
    """


def f(n):
    """ Valósítsa meg az f függvényt, amely n-t vesz paraméterként,
    és egy n méretű listát ad vissza úgy, hogy az i indexben lévő elem értéke az i faktoriálisa, ha i páros
    vagy a számok összege 1-től i-ig egyébként.
    1-től kezdem.
    i faktoriálisa az 1-től i-ig terjedő számok szorzata (1 * 2 * ... * i).
    Példa:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """Implementálja az f függvényt, amely n-t paraméterül kap,
    és egy n hosszúságú listát ad vissza, amelynek az i indexű eleme az i faktoriálisa, ha i páros,
    vagy az 1-től i-ig terjedő számok összege egyébként.
    i kezdete 1.
    Az i faktoriálisa az 1 * 2 * ... * i szorzata.
    Példa:
    f(5) == [1, 2, 6, 24, 15]
    """

def f(n):
    """ Implementálja az f függvényt, amely n paramétert vesz fel,
    és egy n méretű listát ad eredményül úgy, hogy az i indexben lévő elem értéke i faktoriálisa, ha i páros
    vagy egyébként az 1-től i-ig terjedő számok összege.
    1-től kezdem.
    Az i faktoriálisa a számok szorzása 1-től i-ig (1 * 2 * ... * i).
    Példa:
    f(5) == [1, 2, 6, 24, 15]
    """


def even_odd_palindrome(n):
    """
    Ha adott egy pozitív egész szám n, adjon vissza egy tuple-t, amely tartalmazza a páros és páratlan egész palindromikus számok számát az (1, n) tartományban.

    Példa 1:

    Bemenet: 3
    Kimenet: (1, 2)
    Magyarázat:
    Az egész palindromikus számok: 1, 2, 3. Ebből egy páros és kettő páratlan.

    Példa 2:

    Bemenet: 12
    Kimenet: (4, 6)
    Magyarázat:
    Az egész palindromikus számok: 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Ebből négy páros és hat páratlan.

    Hivatkozások:
    1. 1 <= n <= 10^3
    2. A visszaadott tuple tartalmazza a páros és páratlan palindromikus számok számát.
    """

def even_odd_palindrome(n):
    """
    Adott egy n pozitív egész szám, adjon vissza egy tuple-t, amely tartalmazza a páros és páratlan
    egész palindromok számát, amelyek az (1, n) tartományban találhatók.

    1. példa:

        Bemenet: 3
        Kimenet: (1, 2)
        Magyarázat:
        Az egész palindrom 1, 2, 3. Az egyik páros, kettő pedig páratlan.

    2. példa:

        Bemenet: 12
        Kimenet: (4, 6)
        Magyarázat:
        Az egész palindrom 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Ezek közül négy páros, 6 pedig páratlan.

    Jegyzet:
        1. 1 <= n <= 10^3
        2. A visszaadott tuple páros és páratlan egész palindromok számával rendelkezik.
    """

def even_odd_palindrome(n):
    """
    Adott egy n pozitív egész szám. Adj vissza egy értéksort, amelyben a páros
    és páratlan egész szám palindromok száma a range(1, n) tartományba esik
    bezárólagosan.

    1. példa:

        Bemenet: 3
        Kimenet: (1, 2)
        Magyarázat:
        Egész szám palindromok: 1, 2, 3. Közülük egy páros, kettő páratlan.

    2. példa:

        Bemenet: 12
        Kimenet: (4, 6)
        Magyarázat:
        Egész szám palindromok: 1, 2, 3, 4, 5, 6, 7, 8, 9, 11. Közülük négy páros, 6 páratlan.

    Megjegyzés:
        1. 1 <= n <= 10^3
        2. A visszaadott értéksorban páros és páratlan palindrom egész számok is szerepelnek.
    """


def count_nums(arr):
    """
    Írjon egy függvényt count_nums, amely egész számok tömbjét veszi fel, és visszaadja
    azon elemek száma, amelyek számjegyeinek összege > 0.
    Ha egy szám negatív, akkor az első előjele negatív lesz:
    Például a -123 előjele -1, 2 és 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Írjon egy függvényt count_nums amely egy egész számokból álló tömböt vesz, és visszaadja azon elemek számát, amelyek számjegyeinek összege > 0.
    Ha egy szám negatív, az első számjegye az előjellel együtt negatív lesz:
    Példa: -123 számjegyei előjellel -1, 2, 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """

def count_nums(arr):
    """
    Írjon egy count_nums függvényt, amely egész számokból álló tömböt vesz fel, és visszatér
    azoknak az elemeknek a száma, amelyeknél a számjegyek összege > 0.
    Ha egy szám negatív, akkor az első előjelű számjegye negatív lesz:
    például -123 has signed digits -1, 2, and 3.
    >>> count_nums([]) == 0
    >>> count_nums([-1, 11, -11]) == 1
    >>> count_nums([1, 1, 2]) == 3
    """


def move_one_ball(arr):
    """Van egy 'arr' nevű tömbünk, amely N egész számot tartalmaz: arr[1], arr[2], ..., arr[N].
    A számok a tömbben véletlenszerű sorrendben szerepelnek. A feladatod az, hogy meghatározd,
    lehetséges-e a tömböt nem csökkenő sorrendbe rendezni a következő művelet végrehajtásával:
        Tetszőleges számú jobbra eltolást végezhetsz.

    Egy jobbra eltolás művelet alatt azt értjük, hogy minden elem eltolódik egy pozícióval
    a jobb irányba. A tömb utolsó eleme az első helyre kerül, azaz a 0. indexre.

    Ha lehetséges a rendezett tömb elérése a fenti művelet végrehajtásával, akkor True-t kell visszaadni,
    ellenkező esetben False-t. Ha a megadott tömb üres, akkor True-t kell visszaadni.

    Megjegyzés: A megadott lista garantáltan egyedi elemeket tartalmaz.

    Például:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Magyarázat: Két jobbra eltolással elérhető a nem csökkenő sorrend a megadott tömbből.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Magyarázat: Nem lehetséges a nem csökkenő sorrend elérése a megadott tömbből
                semmilyen számú jobbra eltolás végrehajtásával.
    """

def move_one_ball(arr):
    """Van egy tömbünk 'arr' N egész számokból arr[1], arr[2], ..., arr[N]. A
    A tömbben lévő számok véletlenszerűen lesznek rendezve. Az Ön feladata annak meghatározása, hogy
    Lehetőség van arra, hogy egy tömböt nem csökkenő sorrendbe rendezzen a végrehajtással
    A következő művelet az adott tömbön:
        A jobb oldali műszak tetszőleges számú alkalommal hajtható végre.

    Egy jobb oldali eltolásos művelet azt jelenti, hogy a tömb összes elemét egyenként eltolja
    pozíció a helyes irányba. A tömb utolsó eleme a következőre kerül:
    a tömb kiindulási helyzete, azaz 0. index.

    Ha lehetséges a rendezett tömb beszerzése a fenti művelet végrehajtásával
    majd adja vissza az Igaz értéket, különben hamis értéket ad vissza.
    Ha az adott tömb üres, adja vissza az Igaz értéket.

    Megjegyzés: Az adott lista garantáltan egyedi elemeket tartalmaz.

    Például:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Magyarázat: 2 jobb műszakos művelet végrehajtásával a nem csökkenő sorrend
                 az adott tömbre vonatkozóan kell elérni.
    move_one_ball([3, 5, 4, 1, 2])=>False
    Magyarázat:Nem lehet nem csökkenő sorrendet kapni az adott
                tömböt tetszőleges számú jobb oldali váltási művelet végrehajtásával.

    """

def move_one_ball(arr):
    """Van egy 'arr' tömbünk, amely N egész számot tartalmaz: arr[1], arr[2], ..., arr[N].
    A tömbben lévő számok véletlenszerűen vannak elrendezve. A feladat az, hogy megállapítsuk,
    lehetséges-e a tömböt nem csökkenő sorrendbe rendezni az alábbi művelet végrehajtásával:
    A jobbra tolás művelet tetszőleges alkalommal végrehajtható.

    A jobbra tolás művelet azt jelenti, hogy a tömb összes elemét jobbra toljuk
    egy pozícióval. A tömb utolsó eleme az elejére kerül, azaz a 0. indexre.

    Ha a fenti művelet végrehajtható a rendezett tömb eléréséhez, adjon vissza True értéket, különben adjon vissza False értéket.
    Ha a megadott tömb üres, adjon vissza True értéket.

    Megjegyzés: Garantált, hogy a megadott lista egyedi elemeket tartalmaz.

    Példa:

    move_one_ball([3, 4, 5, 1, 2])==>True
    Magyarázat: A megadott tömb nem csökkenő sorrendje elérhető a jobbra tolás művelet 2-szeri végrehajtásával.
    move_one_ball([3, 5, 4, 1, 2])==>False
    Magyarázat: A megadott tömb nem csökkenő sorrendje nem érhető el semmilyen jobbra tolás számával.

    """


def exchange(lst1, lst2):
    """Ebben a feladatban olyan függvényt valósít meg, amely két számlistát vesz fel,
    és meghatározza, hogy lehetséges-e elemcserét végrehajtani
    közöttük, hogy az lst1 csak páros számokból álló lista legyen.
    Az lst1 és lst2 között kicserélt elemek száma nincs korlátozva.
    Ha lehetséges az lst1 és lst2 közötti elemek cseréje
    hogy az lst1 minden eleme páros legyen, adja vissza a "YES"-t.
    Ellenkező esetben adja vissza a „NO”-t.
    Például:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Feltételezzük, hogy a bemeneti listák nem lesznek üresek.
    """

def exchange(lst1, lst2):
    """Ebben a problémában olyan függvényt valósít meg, amely két számlistát vesz fel,
    és meghatározza, hogy lehetséges-e az elemek cseréje
    közöttük, hogy az LST1 csak páros számok listája legyen.
    Az lst1 és lst2 között kicserélt elemek száma nincs korlátozva.
    Ha lehetséges az lst1 és lst2 elemek cseréje
    az lst1 összes eleme, hogy egyenletes legyen, adja vissza az "IGEN" értéket.
    Ellenkező esetben adja vissza a "NEM" értéket.
    Például:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    Feltételezzük, hogy a bemeneti listák nem lesznek üresek.
    """

def exchange(lst1, lst2):
    """Ebben a feladatban olyan függvényt valósít meg, amely két számlistát vesz fel,
    és meghatározza, hogy lehetséges-e elemcserét végrehajtani
    közöttük, hogy az lst1 csak páros számokból álló lista legyen.
    Az lst1 és lst2 között kicserélt elemek száma nincs korlátozva.
    Ha lehetséges az lst1 és lst2 közötti elemek cseréje
    hogy az lst1 minden eleme páros legyen, adja vissza a "YES"-t.
    Ellenkező esetben adja vissza a „NO”-t.
    Például:
    exchange([1, 2, 3, 4], [1, 2, 3, 4]) => "YES"
    exchange([1, 2, 3, 4], [1, 5, 3, 4]) => "NO"
    It is assumed that the input lists will be non-empty.
    """


def histogram(test):
    """Adott egy sztring, amely szóközökkel elválasztott kisbetűs karaktereket tartalmaz, és vissza kell adni egy szótárat,
    amely a leggyakrabban előforduló karaktereket és azok megfelelő számát tartalmazza.
    Ha több karakternek ugyanannyi előfordulása van, akkor mindegyiket vissza kell adni.

    Példa:
    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):
    """Adott egy karakterlánc, amely szóközt jelöl kisbetűkkel, adjon vissza egy szótárt
    a legtöbb ismétléssel rendelkező és a megfelelő számot tartalmazó levélből.
    Ha több betű előfordulása azonos, adja vissza mindegyiket.

    Példa:
    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):
    """Adott egy karakterlánc, amely szóközzel elválasztott kisbetűket jelent, szótárt ad vissza
    a legtöbbször ismétlődő és a megfelelő számot tartalmazó levél.
    Ha több betű is előfordul ugyanaz, adja vissza mindegyiket.

    Példa:
    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):
    """Feladat
    Két karakterláncot s és c kapunk, töröljük az s-ből azokat a karaktereket, amelyek megegyeznek a c-ben szereplő karakterekkel,
    majd ellenőrizzük, hogy az eredményül kapott karakterlánc palindróma-e.
    Egy karakterlánc akkor palindróma, ha hátrafelé olvasva ugyanaz, mint előrefelé.
    Vissza kell adni egy tuple-t, amely tartalmazza az eredmény karakterláncot és az igaz/hamis értéket az ellenőrzéshez.
    Példa:
    Ha s = "abcde", c = "ae", az eredménynek ('bcd',False)-nak kell lennie.
    Ha s = "abcdef", c = "b", az eredménynek ('acdef',False)-nak kell lennie.
    Ha s = "abcdedcba", c = "ab", az eredménynek ('cdedc',True)-nak kell lennie.
    """

def reverse_delete(s,c):
    """Feladat
    Két s és c karakterláncot kapunk, törölnünk kell az összes karaktert s-ben, amely megegyezik a c bármely karakterével
    Ezután ellenőrizze, hogy az eredmény karakterlánca palindrom.
    A karakterláncot palindromnak nevezzük, ha ugyanazt olvassa visszafelé, mint előre.
    Az ellenőrzéshez egy rekordot kell visszaadnia, amely tartalmazza az eredménysztringet és az Igaz/Hamis értéket.
    Példa
    s = "abcde", c = "ae" esetén az eredménynek ('bcd',False) kell lennie
    s = "abcdef", c = "b" esetén az eredménynek ('acdef',False) kell lennie
    s = "abcdedcba", c = "ab" esetén az eredménynek ('cdedc',True) kell lennie
    """

def reverse_delete(s,c):
    """Feladat
    Két s és c karakterláncot kapunk, törölnie kell az összes olyan karaktert az s-ből, amely megegyezik a c bármely karakterével
    majd ellenőrizze, hogy az eredmény karakterlánc palindrom-e.
    Egy karakterláncot palindromnak nevezünk, ha visszafelé ugyanazt olvassa, mint előre.
    Az ellenőrzéshez vissza kell adnia egy sort, amely tartalmazza az eredmény karakterláncot és a True/False értéket.
    Példa
    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 odd_count(lst):
    """Meg van adva egy karakterlánc lista, amelyben minden lánc csak számjegyeket tartalmaz.
    A kimeneti lista minden egyes elemének "a páratlan elemek számának az i-edik bemeneti karakterláncban" kell lennie.
    Itt minden i-t a páratlan számjegyek számával kell helyettesíteni az i-edik bemeneti karakterláncban.

    >>> 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):
    """Adott karakterláncok listája, ahol minden karakterlánc csak számjegyekből áll, adjon vissza egy listát.
    A kimenet minden i elemének "a páratlan elemek számának kell lennie a
    a bemenet i karakterlánca." ahol az összes i-t a számmal kell helyettesíteni
    páratlan számjegyek száma a bemenet i-edik karakterláncában.

    >>> 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):
    """Adott egy karakterláncokat tartalmazó lista, ahol minden karakterlánc csak számjegyekből áll. Adj vissza egy listát.
    Az eredmény minden egyes i-edik eleme legyen: "a páratlan elemek száma az i-edik karakterláncban a bemenetben."
    ahol az összes i-t cseréld ki a páratlan számjegyek számával a bemenet i-edik karakterláncában.

    >>> 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):
    """
    Egy egész számokat tartalmazó tömb nums van megadva, találja meg a legkisebb összeget
    bármely nem üres rész-tömbből nums-ban.
    Példa:
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Adott egész számok tömbje esetén keresse meg a nem üres résztömbök minimális összegét
    szám.
    Példa
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """

def minSubArraySum(nums):
    """
    Adott egy egész számokból álló tömböt, keresse meg bármely nem üres altömb minimális összegét
    számokból.
    Példa
    minSubArraySum([2, 3, 4, 1, 2, 4]) == 1
    minSubArraySum([-1, -2, -3]) == -6
    """


import math

def max_fill(grid, capacity):
    """
    Egy téglalap alakú kutakból álló rácsot kapsz. Minden sor egyetlen kutat jelent,
    és minden 1 egy sorban egy egységnyi vizet jelöl.
    Minden kút rendelkezik egy megfelelő vödörrel, amelyet a víz kinyerésére lehet használni,
    és minden vödör azonos kapacitású.
    A feladatod az, hogy a vödröket használva kiürítsd a kutakat.
    Add meg, hányszor kell leereszteni a vödröket.

    Példa 1:
        Bemenet:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Kimenet: 6

    Példa 2:
        Bemenet:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Kimenet: 5

    Példa 3:
        Bemenet:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Kimenet: 0

    Korlátok:
        * minden kút azonos hosszúságú
        * 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):
    """
    Kapsz egy téglalap alakú rácsot. Minden sor egyetlen lyukat képvisel,
    és minden 1 sorban egyetlen vízegységet képvisel.
    Minden lyuknak van egy megfelelő vödör, amely felhasználható a víz kivonására,
    És minden vödör azonos kapacitással rendelkezik.
    Az Ön feladata, hogy a vödröket használja a kutak kiürítésére.
    Adja ki, hogy hányszor kell leengednie a vödröket.

    1. példa:
        Bemenet:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Kimenet: 6

    2. példa:
        Bemenet:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Kimenet: 5

    3. példa:
        Bemenet:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Kimenet: 0

    Korlátok:
        * minden kút azonos hosszúságú
        * 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):
    """
    Kapsz egy téglalap alakú kutak rácsot. Minden sor egyetlen lyukat jelöl,
    és a sorban minden 1 egyetlen vízegységet jelent.
    Minden kúthoz tartozik egy megfelelő vödör, amellyel vizet lehet kinyerni belőle,
    és minden vödör azonos kapacitású.
    Az Ön feladata, hogy a vödrök segítségével ürítse ki a kutakat.
    Adja meg, hányszor kell leengednie a vödröket.

    1. példa:
        Bemenet:
            grid : [[0,0,1,0], [0,1,0,0], [1,1,1,1]]
            bucket_capacity : 1
        Kimenet: 6

    2. példa:
        Bemenet:
            grid : [[0,0,1,1], [0,0,0,0], [1,1,1,1], [0,1,1,1]]
            bucket_capacity : 2
        Kimenet: 5

    3. példa:
        Bemenet:
            grid : [[0,0,0], [0,0,0]]
            bucket_capacity : 5
        Kimenet: 0

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


def sort_array(arr):
    """
    Ebben a feladatban egy nem negatív egész számokat tartalmazó listát kell rendezni az
    alapján, hogy hány darab egyes szerepel a bináris ábrázolásukban növekvő sorrendben.
    Ha két számnak ugyanannyi egyese van, akkor azoknak a tízes számrendszerbeli értéke alapján kell rendezni.

    Így kell megvalósítani:
    >>> 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):
    """
    Ebben a katában a nemnegatív egész számok tömbjét kell rendezni a következők szerint
    bináris ábrázolásukban növekvő sorrendben lévők száma.
    Hasonló számú esetén rendezzen decimális érték alapján.

    Ezt így kell végrehajtani:
    >>> 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):
    """
    Ebben a Katában egy nem negatív egész számok tömbjét kell a szerint rendezni
    az egyesek száma a bináris ábrázolásukban növekvő sorrendben.
    Ha hasonló számú darabot szeretne, rendezze a tizedesjegyek alapján.

    Ezt így kell megvalósítani:
    >>> 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):
    """Adott egy s karakterlánc és egy természetes szám n, a feladat egy olyan
    függvény megvalósítása, amely visszaadja az s karakterláncból mindazon szavak listáját,
    amelyek pontosan n mássalhangzót tartalmaznak, abban a sorrendben, ahogy ezek a szavak
    megjelennek az s karakterláncban.
    Ha az s karakterlánc üres, akkor a függvény egy üres listát adjon vissza.
    Megjegyzés: feltételezhető, hogy a bemeneti karakterlánc csak betűket és szóközöket tartalmaz.
    Példák:
    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):
    """Adott egy s karakterlánc és egy n természetes szám, azt a feladatot kapta, hogy valósítsa meg
    Egy függvény, amely visszaadja az S karakterlánc összes olyan szavának listáját, amely pontosan tartalmazza
    n mássalhangzók, annak érdekében, hogy ezek a szavak megjelenjenek az s karakterláncban.
    Ha az s karakterlánc üres, akkor a függvénynek üres listát kell visszaadnia.
    Megjegyzés: feltételezheti, hogy a bemeneti karakterlánc csak betűket és szóközöket tartalmaz.
    Példák:
    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):
    """Ha adott egy s karakterlánc és egy természetes szám n, implementálni kell egy függvényt,
    amely visszaadja az s karakterlánc összes olyan szavának listáját, amelyek pontosan n mássalhangzót tartalmaznak.
    Ezek a szavak az s karakterláncban való megjelenésük sorrendjében kerülnek vissza.
    Ha az s karakterlánc üres, a függvénynek egy üres listát kell visszaadnia.
    Megjegyzés: Feltételezhetjük, hogy a bemeneti karakterlánc csak betűket és szóközöket tartalmaz.
    Példa:
    select_words("Mary had a little lamb", 4) ==> ["little"]
    select_words("Mary had a little lamb", 3) ==> ["Mary", "lamb"]
    select_words("simple white space", 2) ==> []
    select_words("Hello world", 4) ==> ["world"]
    select_words("Uncle sam", 3) ==> ["Uncle"]
    """


def get_closest_vowel(word):
    """Egy szót kapsz. A feladatod, hogy megtaláld a legközelebbi magánhangzót, amely két mássalhangzó között áll a szó jobb oldalán (nagy- és kisbetű érzékeny).

    Az elején és végén lévő magánhangzók nem számítanak. Ha nem találsz olyan magánhangzót, amely megfelel a fenti feltételnek, üres karakterláncot kell visszaadnod.

    Feltételezheted, hogy a megadott karakterlánc csak angol betűket tartalmaz.

    Példa:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Kapsz egy szót. Az Ön feladata, hogy megtalálja a legközelebbi magánhangzót, amely között áll
    két mássalhangzó a szó jobb oldaláról (megkülönbözteti a kis- és nagybetűket).

    Az elején és végén lévő magánhangzók nem számítanak. Üres karakterlánc visszaadása, ha nem
    Keresse meg a fenti feltételnek megfelelő magánhangzókat.

    Feltételezheti, hogy az adott karakterlánc csak angol betűt tartalmaz.

    Példa:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """

def get_closest_vowel(word):
    """Egy szót kapsz. Az Ön feladata, hogy megtalálja a legközelebbi magánhangzót, amely között van
    két mássalhangzó a szó jobb oldaláról (kis- és nagybetű).

    Az elején és a végén lévő magánhangzók nem számítanak. Ha nem tette meg, adjon vissza üres karakterláncot
    megtalálja a fenti feltételnek megfelelő magánhangzót.

    Feltételezheti, hogy az adott karakterlánc csak angol betűt tartalmaz.

    Példa:
    get_closest_vowel("yogurt") ==> "u"
    get_closest_vowel("FULL") ==> "U"
    get_closest_vowel("quick") ==> ""
    get_closest_vowel("ab") ==> ""
    """


def match_parens(lst):
    '''
    Adott egy két sztringet tartalmazó lista. Mindkét sztring csak
    nyitó '(' vagy záró ')' zárójeleket tartalmaz.
    A feladatod az, hogy ellenőrizd, hogy lehetséges-e a két sztringet
    valamilyen sorrendben konkatenálni, hogy a kapott sztring jó legyen.
    Az S sztring akkor és csak akkor tekinthető jónak, ha az S-ben lévő
    minden zárójel kiegyensúlyozott. Például: a '(())()' sztring jó, míg a
    '())' sztring nem jó.
    Ha lehetséges jó sztringet alkotni, akkor 'Yes'-t adj vissza, egyébként
    pedig 'No'-t.

    Példák:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Két karakterlánc listáját kapja, mindkét karakterlánc nyitott
    csak zárójelek '(' vagy zárójelek bezárása ')".
    Az Ön feladata annak ellenőrzése, hogy lehetséges-e a két karakterlánc összefűzése
    valamilyen sorrendben, hogy a kapott karakterlánc jó lesz.
    Egy S karakterlánc akkor és csak akkor tekinthető jónak, ha az S összes zárójele
    kiegyensúlyozottak. Például: a "(())()" karakterlánc jó, míg a karakterlánc
    A "())" nem az.
    Visszatérés "Igen", ha van mód egy jó karakterlánc létrehozására, és adja vissza a "Nem" értéket egyébként.

    Példák:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''

def match_parens(lst):
    '''
    Kapsz egy listát két karakterláncból, mindkét karakterlánc nyitott karakterláncból áll
    csak a zárójelek '(' vagy a zárójelek bezárása ')'.
    Az Ön feladata annak ellenőrzése, hogy lehetséges-e a két karakterlánc összefűzése
    bizonyos sorrendben, hogy az eredményül kapott karakterlánc jó legyen.
    Az S karakterlánc akkor és csak akkor tekinthető jónak, ha az összes zárójel S-ben van
    kiegyensúlyozottak. Például: a '(())()' karakterlánc jó, míg a karakterlánc
    '())' nem.
    Ha van mód jó karakterlánc létrehozására, térjen vissza 'Yes', különben térjen vissza 'No'.

    Példák:
    match_parens(['()(', ')']) == 'Yes'
    match_parens([')', ')']) == 'No'
    '''


def maximum(arr, k):
    """
    Adott egy egész számokat tartalmazó arr tömb és egy pozitív egész szám k.
    Vissza kell adni egy rendezett listát, amelynek hossza k, és tartalmazza a
    legnagyobb k számot az arr tömbből.

    Példa 1:

        Bemenet: arr = [-3, -4, 5], k = 3
        Kimenet: [-4, -3, 5]

    Példa 2:

        Bemenet: arr = [4, -4, 4], k = 2
        Kimenet: [4, 4]

    Példa 3:

        Bemenet: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Kimenet: [2]

    Megjegyzés:
        1. A tömb hossza [1, 1000] tartományban lesz.
        2. A tömb elemei [-1000, 1000] tartományban lesznek.
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Adott egy egész számokból álló arr tömb és egy k egész szám, egy rendezett listát ad vissza
    k hosszúságú az arr-ból a legnagyobb k számot tartalmazó.

    1. példa:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    2. példa:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    3. példa:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Jegyzet:
        1. A tömb hossza a tartományba esik [1, 1000].
        2. A tömb elemei a tartományba esnek [-1000, 1000].
        3. 0 <= k <= len(arr)
    """

def maximum(arr, k):
    """
    Adott egy tömb arr egész szám és egy pozitív k egész szám, adjon vissza egy rendezett listát
    k hosszúságú, a maximális k számok arr-ban.

    1. példa:

        Input: arr = [-3, -4, 5], k = 3
        Output: [-4, -3, 5]

    2. példa:

        Input: arr = [4, -4, 4], k = 2
        Output: [4, 4]

    3. példa:

        Input: arr = [-3, 2, 1, 2, -1, -2, 1], k = 1
        Output: [2]

    Jegyzet:
        1. A tömb hossza [1, 1000] tartományban lesz.
        2. A tömb elemei [-1000, 1000] tartományban lesznek.
        3. 0 < = k <= len(arr)
    """


def solution(lst):
    """Az egész számok nem üres listája esetén adja vissza a páros pozícióban lévő páratlan elemek összegét.

    Példák
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Adott egy nem üres egész lista esetén adja vissza az összes páratlan elem összegét, amelyek páros helyzetben vannak.

    Példák
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==>0
    """

def solution(lst):
    """Adott egy nem üres egész számokat tartalmazó lista, térjen vissza az összeggel az összes páratlan számú elemeknek, amelyek páros pozíciókban vannak.

    Példák:
    solution([5, 8, 7, 1]) ==> 12
    solution([3, 3, 3, 3, 3]) ==> 9
    solution([30, 13, 24, 321]) ==> 0
    """


def add_elements(arr, k):
    """
    Adott egy arr és egy k egész számokból álló nem üres tömb, return
    az arr első k eleméből legfeljebb két számjegyű elemek összege.

    Példa:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

    Korlátozások:
        1. 1 <= len(arr) <= 100
        2. 1 <= k <= len(arr)
    """

def add_elements(arr, k):
    """
    Adott egy arr és egy k egész számokból álló nem üres tömb, return
    az arr első k eleméből legfeljebb két számjegyű elemek összege.

    Példa:

        Input: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Output: 24 # sum of 21 + 3

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

def add_elements(arr, k):
    """
    Adott egy nem üres tömb arr egész számokból és egy k egész számból, adja vissza a következőt:
    Az ARR első k eleméből legfeljebb két számjegyből álló elemek összege.

    Példa:

        Bemenet: arr = [111,21,3,4000,5,6,7,8,9], k = 4
        Kimenet: 24 # 21 + 3 összege

    Korlátok:
        1. 1 < = len(arr) <= 100
        2. 1 < = k <= len(arr)
    """


def get_odd_collatz(n):
    """
    Adott egy n pozitív egész szám. Adj vissza egy rendezett listát, amelyben a páratlan számok
    Collatz-sorozatot alkotnak.

    A Collatz-sejtés egy matematikai sejtés az alábbiak szerint definiált sorozatról:
    Induljunk ki egy tetszőleges n pozitív egész számból. Minden elem az előző elemből
    származódik a következőképpen: ha az előző elem páros, akkor a következő elem az
    előző elem fele. Ha az előző elem páratlan, akkor a következő elem az előző elem
    háromszorosa plusz 1. A sejtés azt mondja ki, hogy n értékétől függetlenül a sorozat mindig eléri
    az 1-et.

    Megjegyzés:
        1. A Collatz(1) értéke [1].
        2. A visszaadott lista növekvő sorrendben van rendezve.

    Például:
    A get_odd_collatz(5) által visszaadott érték [1, 5] # A Collatz-sorozat 5 esetén [5, 16, 8, 4, 2, 1], így csak az 1 és az 5 páratlan szám.
    """

def get_odd_collatz(n):
    """
    Adott egy pozitív n egész szám, adjon vissza egy rendezett listát, amely páratlan számokat tartalmaz collatz sorrendben.

    A Collatz-sejtés a matematikában egy olyan sejtés, amely egy meghatározott sorozatra vonatkozik
    a következőképpen: Kezdje bármely pozitív n egész számmal. Ezután minden kifejezést a
    előző ciklus a következőképpen: ha az előző ciklus páros, a következő ciklus a
    az előző ciklus. Ha az előző kifejezés páratlan, a következő kifejezés az előző 3-szorosa
    időtartam plusz 1. A feltételezés az, hogy függetlenül attól, hogy n milyen értékű, a sorozat mindig eléri az 1-et.

    Jegyzet:
        1. A Collatz(1) [1].
        2. A visszaadott lista növekvő sorrendben rendezve.

    Például:
    get_odd_collatz(5) eredménye [1, 5] # Az 5 collatz sorozata [5, 16, 8, 4, 2, 1], így a páratlan számok csak 1 és 5.
    """

def get_odd_collatz(n):
    """
    Adott egy n pozitív egész szám, adjon vissza egy rendezett listát, amelyben a páratlan számok collatz sorrendben vannak.

    A Collatz-sejtés egy olyan matematikai sejtés, amely egy meghatározott sorozatra vonatkozik
    a következőképpen: kezdje tetszőleges n pozitív egész számmal. Ezután minden kifejezést a
    előző tag a következőképpen: ha az előző tag páros, a következő tag fele
    az előző kifejezés. Ha az előző tag páratlan, a következő tag az előző háromszorosa
    tag plusz 1. A sejtés az, hogy függetlenül attól, hogy mekkora n értéke, a sorozat mindig eléri az 1-et.

    Jegyzet:
        1. Collatz(1) is [1].
        2. returned list sorted in increasing order.

    Például:
    get_odd_collatz(5) returns [1, 5] # The collatz sequence for 5 is [5, 16, 8, 4, 2, 1], so the odd numbers are only 1, and 5.
    """


def valid_date(date):
    """Írj egy függvényt, amely validál egy adott dátum stringet, és
    True értéket ad vissza, ha a dátum érvényes, különben False-t.
    A dátum akkor érvényes, ha az alábbi szabályok mindegyike teljesül:
    1. A dátum string nem üres.
    2. A napok száma nem lehet kevesebb, mint 1, és nem haladhatja meg a 31-et az 1., 3., 5., 7., 8., 10., 12. hónapokban. A napok száma nem lehet kevesebb, mint 1, és nem haladhatja meg a 30-at a 4., 6., 9., 11. hónapokban. És a napok száma nem lehet kevesebb,              mint 1, és nem haladhatja meg a 29-et a 2. hónapban.
    3. A hónapok nem lehetnek kisebbek, mint 1, és nem haladhatják meg a 12-t.
    4. A dátumnak az alábbi formátumot kell követnie: mm-dd-yyyy

    Például:
    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):
    """Meg kell írnia egy függvényt, amely érvényesíti az adott dátumkarakterláncot, és
    Igaz értéket ad vissza, ha a dátum érvényes, egyébként Hamis.
    A dátum akkor érvényes, ha az alábbi szabályok mindegyike teljesül:
    1. A dátum karakterlánc nem üres.
    2. A napok száma legalább 1 vagy több, mint 31 nap az 1,3,5,7,8,10,12 hónapokban. És a napok száma nem kevesebb, mint 1 vagy nagyobb, mint 30 nap a 4,6,9,11 hónapokban. És a napok száma nem kevesebb, mint 1 vagy magasabb, mint 29 a 2. hónapban.
    3. A hónapok nem lehetnek 1-nél rövidebbek vagy 12-nél nagyobbak.
    4. A dátumnak a következő formátumban kell lennie: hh-nn-éééé

    például:
    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):
    """Írnod kell egy függvényt, amely érvényesíti az adott dátum karakterláncot és
    Igaz értéket ad vissza, ha a dátum érvényes, ellenkező esetben False.
    A dátum akkor érvényes, ha az alábbi szabályok mindegyike teljesül:
    1. A dátum karakterlánc nem üres.
    2. Az 1,3,5,7,8,10,12 hónapra vonatkozóan a napok száma nem lehet kevesebb 1-nél és több mint 31 nap. A napok száma pedig nem kevesebb, mint 1 vagy több, mint 30 nap a 4,6,9,11 hónapokban. És a napok száma a 2. hónapban nem lehet kevesebb 1-nél vagy több, mint 29.
    3. A hónapok nem lehetnek kevesebbek 1-nél és nem lehetnek magasabbak 12-nél.
    4. A dátumnak a következő formátumban kell lennie: mm-nn-yyyy

    például:
    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):
    '''
    Adott egy szöveg, amely szavakat tartalmaz. A feladat az, hogy egy listát adjon vissza,
    amelyben a szavak szóközökkel vannak elválasztva. Ha nincs szóköz a szövegben,
    akkor vesszőkön ',' kell szétválasztani a szavakat. Ha nincs vessző sem, akkor
    vissza kell adni azokat a kisbetűs betűket, amelyek páratlan helyen szerepelnek
    az ABC-ben, ord('a') = 0, ord('b') = 1, ... ord('z') = 25.

    Példák:
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Adott egy szóláncot, adja vissza a szóközökre felosztott szavak listáját, ha nincs szóköz a szövegben
    vesszőkre kell osztani, ha nincs vessző, akkor a páratlan sorrendű kisbetűk számát kell visszaadni
    ábécé, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Példák
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''

def split_words(txt):
    '''
    Adott egy szósorozat, adja vissza a szóközökre osztott szavak listáját, ha nincs szóköz a szövegben
    vesszőre kell osztani ',' ha nincs vessző, akkor a kisbetűk számát páratlan sorrendben kell visszaadni a
    ábécé, ord('a') = 0, ord('b') = 1, ... ord('z') = 25
    Példák
    split_words("Hello world!") ➞ ["Hello", "world!"]
    split_words("Hello,world!") ➞ ["Hello", "world!"]
    split_words("abcdef") == 3
    '''


def is_sorted(lst):
    '''
    Adott egy számlista. Azt add vissza, hogy a számok
    növekvő sorrendben rendezettek-e. Ha a listában ugyanaz a szám kettőnél
    többször szerepel, akkor False értéket adj vissza. Tegyük fel, hogy nincsenek
    negatív számok, és csak egész számokat tartalmaz a lista.

    Példák
    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):
    '''
    Adott számlista esetén adja vissza, függetlenül attól, hogy rendezve vannak-e vagy sem
    növekvő sorrendben. Ha a listának több mint 1 ismétlődése van ugyanabból
    szám, visszatérési érték Hamis. Tegyük fel, hogy nincsenek negatív számok, csak egész számok.

    Példák
    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):
    '''
    Adott egy számlistát, adja vissza, függetlenül attól, hogy rendezve vannak-e vagy sem
    növekvő sorrendben. Ha a listában ugyanannak több mint 1 másolata van
    szám, return False. Tételezzük fel, hogy nincsenek negatív számok, és csak egész számok.

    Példák
    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):
    """ Két intervallumot kap,
    ahol minden intervallum egy pár egész szám. Például, interval = (kezdet, vég) = (1, 2).
    Az intervallumok zártak, ami azt jelenti, hogy az intervallum (kezdet, vég)
    tartalmazza a kezdő- és végpontokat is.
    Minden adott intervallum esetében feltételezhető, hogy a kezdete kisebb vagy egyenlő a végénél.
    A feladat, hogy meghatározza, hogy a két intervallum metszetének hossza egy prímszám-e.
    Példa: az (1, 3) és (2, 4) intervallumok metszete (2, 3), amelynek hossza 1, ami nem prímszám.
    Ha a metszet hossza prímszám, adja vissza a "YES" választ, egyébként adja vissza a "NO" választ.
    Ha a két intervallum nem metszi egymást, adja vissza a "NO" választ.

    [bemenet/kimenet] minták:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Két intervallumot kapsz,
    ahol minden intervallum egy pár egész szám. Például intervallum = (kezdet, vége) = (1, 2).
    A megadott intervallumok zártak, ami azt jelenti, hogy az intervallum (kezdete, vége)
    magában foglalja a kezdetet és a végét is.
    Minden adott intervallum esetében feltételezzük, hogy a kezdete kisebb vagy egyenlő a végével.
    Az Ön feladata annak meghatározása, hogy e kettő metszéspontjának hossza
    intervallum egy prímszám.
    Például az (1, 3), (2, 4) intervallumok metszéspontja (2, 3)
    amelynek hossza 1, ami nem prímszám.
    Ha a metszés hossza prímszám, akkor térjen vissza "YES",
    ellenkező esetben vissza "NO".
    Ha a két intervallum nem metszi egymást, térjen vissza "NO".

    [bemenet/kimenet] minták:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """

def intersection(interval1, interval2):
    """Két intervallumot kapsz,
    ahol minden intervallum egész számok párja. Például intervallum = (kezdet, vég) = (1, 2).
    Az adott intervallumok zárva vannak, ami azt jelenti, hogy az intervallum (kezdet, vég)
    tartalmazza az elejét és a végét is.
    Minden adott intervallum esetében feltételezzük, hogy kezdete kisebb vagy egyenlő a végével.
    Az Ön feladata annak meghatározása, hogy a kettő metszéspontjának hossza
    Az intervallumok prímszám.
    Példa: az (1, 3), (2, 4) intervallumok metszéspontja (2, 3)
    amelynek hossza 1, ami nem prímszám.
    Ha a kereszteződés hossza prímszám, adja vissza az "IGEN" értéket,
    ellenkező esetben adja vissza a "NEM" értéket.
    Ha a két intervallum nem metszi egymást, adja vissza a "NEM" értéket.

    [bemeneti/kimeneti] minták:
    intersection((1, 2), (2, 3)) ==> "NO"
    intersection((-1, 1), (0, 4)) ==> "NO"
    intersection((-3, -1), (-5, 5)) ==> "YES"
    """


def prod_signs(arr):
    """
    Kapsz egy egész számokból álló tömböt, és vissza kell térned
    egész számok nagyságának összege szorozva az összes előjel szorzatával
    a tömb minden számának 1, -1 vagy 0 jelölése.
    Megjegyzés: return None üres arr.

    Példa:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """

def prod_signs(arr):
    """
    Egész számokból álló tömb arr-t kap, és vissza kell térnie
    egész számok nagyságrendjeinek összege szorozva az összes jel szorzatával
    a tömb minden számából, amelyet 1, -1 vagy 0 képvisel.
    Megjegyzés: üres arr.

    Példa:
    >>> prod_signs([1, 2, 2, -4]) == -9
    >>> prod_signs([0, 1]) == 0
    >>> prod_signs([]) == None
    """


def minPath(grid, k):
    """
    Adott egy rács N sorral és N oszloppal (N >= 2), és egy pozitív egész szám k.
    A rács minden cellája tartalmaz egy értéket. A [1, N * N] tartományban bezárólag lévő
    minden egész szám pontosan egyszer jelenik meg a rács celláiban.

    Találd meg a rácsban a k hosszúságú legrövidebb útvonalat. Bármely
    cellából elindulhatsz, és minden lépésben bármely szomszédos cellába átléphetsz.
    Más szóval azokba a cellákba léphetsz át, amelyeknek közös oldala van azzal a cellával,
    amelyből átlépsz.
    Vedd figyelembe, hogy a k hosszúságú útvonal azt jelenti, hogy pontosan k számú cellába lépsz át
    (de nem feltétlenül különbözőekbe).
    A rácsot NEM hagyhatod el.
    A (k hosszúságú) A útvonal akkor tekintendő rövidebbnek, mint a (k hosszúságú) B útvonal, ha
    az egyes útvonalak celláinak az értékeiből álló rendezett listák létrehozását követően
    (legyenek lst_A and lst_B) a lst_A lexikografikusan rövidebb, mint a lst_B,
    más szóval létezik olyan egész szám i index (1 <= i <= k), amelyre igaz, hogy
    lst_A[i] < lst_B[i] és bármely j (1 <= j < i) esetében igaz, hogy lst_A[j] = lst_B[j].
    A válasz garantáltan egyedi.
    Azon cellák értékeinek rendezett listáját add vissza, amelyeken a legrövidebb útvonal áthalad.

    Példák:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    Adott egy N sorból és N oszlopból álló rács (N >= 2) és egy k pozitív egész szám,
    a rács minden cellája tartalmaz egy értéket. Minden egész szám az [1, N * N] tartományban
    inclusive pontosan egyszer jelenik meg a rács celláin.

    Meg kell találni a minimális k hosszúságú utat a rácsban. Kezdheted
    bármelyik cellából, és minden lépésben bármelyik szomszédos cellába léphet,
    más szóval, olyan cellákra léphet, amelyek egy élen osztoznak Önnel
    sejt.
    Kérjük, vegye figyelembe, hogy a k hosszúságú útvonal pontosan k cella meglátogatását jelenti (nem
    szükségszerűen különálló).
    NEM LEHET kilépni a rácsról.
    Egy (k hosszúságú) A utat kisebbnek tekintünk, mint egy (k hosszúságú) B utat, ha
    miután elkészítette az értékek rendezett listáját azokon a cellákon, amelyekre A és B megy
    keresztül (nevezzük őket lst_A-nak és lst_B-nek), az lst_A lexikográfiailag kevésbé
    mint lst_B, más szóval létezik egy egész index i (1 <= i <= k)
    úgy, hogy lst_A[i] < lst_B[i] és bármely j-re (1 <= j < i) van
    lst_A[j] = lst_B[j].
    Garantáltan egyedi a válasz.
    Visszaadja azoknak a celláknak az értékeinek rendezett listáját, amelyeken a minimális útvonal áthalad.

    Példák:

        Input: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Output: [1, 2, 1]

        Input: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Output: [1]
    """

def minPath(grid, k):
    """
    Adott egy N sorból és N oszlopból álló rács (N >= 2) és egy k pozitív egész szám,
    A rács minden cellája tartalmaz egy értéket. Minden egész szám a tartományban [1, N * N]
    Az inkluzív pontosan egyszer jelenik meg a rács celláin.

    Meg kell találnia a k hosszúságú minimális utat a rácsban. Elkezdheti
    bármely cellából, és minden lépésben bármelyik szomszédos cellába léphet,
    Más szavakkal, olyan cellákra léphet, amelyek élnek az Ön jelenlegi
    sejt.
    Kérjük, vegye figyelembe, hogy a k hosszúságú út pontosan k cella látogatását jelenti (nem
    szükségszerűen eltérő).
    NEM tudsz lelépni a hálózatról.
    Egy (k hosszúságú) A út akkor tekinthető kisebbnek, mint egy B (k hosszú) út, ha
    miután elkészítette az A és B cellák értékeinek rendezett listáját
    keresztül (nevezzük őket lst_A és lst_B), lst_A lexikográfiailag kevesebb
    mint lst_B, más szóval létezik egy i egész index (1 <= i <= k)
    úgy, hogy lst_A[i] < lst_B[i] és bármely j (1 <= j < i)
    lst_A[j] = lst_B[j].
    Garantált, hogy a válasz egyedi.
    Azon cellák értékeinek rendezett listáját adja vissza, amelyeken a minimális elérési út áthalad.

    Példák:

        Bemenet: grid = [ [1,2,3], [4,5,6], [7,8,9]], k = 3
        Kimenet: [1, 2, 1]

        Bemenet: grid = [ [5,9,3], [4,1,6], [7,8,2]], k = 1
        Kimenet: [1]
    """


def tri(n):
    """Mindenki ismeri a Fibonacci-sorozatot, amelyet a matematikusok évszázadok óta tanulmányoznak.
    Azonban kevésbé ismert a Tribonacci-sorozat.
    A Tribonacci-sorozat a következő rekurzív képlettel van meghatározva:
    tri(1) = 3
    tri(n) = 1 + n / 2, ha n páros szám.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), ha n páratlan szám.
    Példa:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
    = 2 + 3 + 3 = 8
    Ha egy nem negatív egész szám n van megadva, vissza kell adnia a Tribonacci-sorozat első n + 1 számainak listáját.
    Példa:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    ""Mindenki ismeri a Fibonacci-szekvenciát, a matematikusok mélyen tanulmányozták
    az elmúlt néhány évszázadban. Amit azonban az emberek nem tudnak, az a Tribonacci-szekvencia.
    A Tribonacci-szekvenciát az ismétlődés határozza meg:
    tri(1) = 3
    tri(n) = 1 + n / 2, ha n páros.
    tri(n) = tri(n - 1) + tri(n - 2) + tri(n + 1), ha n páratlan.
    Például:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Kapsz egy nem negatív egész számot n szám, vissza kell adnod egy listát a
    a Tribonacci-szekvencia első n + 1 száma.
    Példák:
    tri(3) = [1, 3, 2, 8]
    """

def tri(n):
    """Mindenki ismeri a Fibonacci-számokat, amelyeket a matematikusok
    az utóbbi évszázadokban alaposan tanulmányoztak. Kevesen ismerik viszont a
    Tribonacci-számokat. A Tribonacci-számokat az alábbi rekurzív megoldással kaphatjuk meg:
    tri(1) = 3
    tri(n) = 1 + n / 2, ha n páros szám.
    tri(n) =  tri(n - 1) + tri(n - 2) + tri(n + 1), ha n páratlan szám.
    Például:
    tri(2) = 1 + (2 / 2) = 2
    tri(4) = 3
    tri(3) = tri(2) + tri(1) + tri(4)
           = 2 + 3 + 3 = 8
    Ha n egy nem negatív egész szám, akkor a Tribonacci-sorozat első n + 1 számának listáját kell visszaadni.
    Példák:
    tri(3) = [1, 3, 2, 8]
    """


def digits(n):
    """Adott n pozitív egész szám, adja vissza a páratlan számjegyek szorzatát.
    0-val tér vissza, ha minden számjegy páros.
    Például:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Adott egy pozitív n egész szám, adja vissza a páratlan számjegyek szorzatát.
    Visszatérési értéke 0, ha minden számjegy páros.
    Például:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """

def digits(n):
    """Adott egy pozitív egész számot n, és visszaadja a páratlan számjegyek szorzatát.
    Visszaad 0-t, ha minden számjegy páros.
    Például:
    digits(1)  == 1
    digits(4)  == 0
    digits(235) == 15
    """


def is_nested(karakterlánc):
    '''
    Hozzon létre egy függvényt, amely csak szögletes zárójeleket tartalmazó karakterláncot vesz fel bemenetként.
    A függvénynek akkor és csak akkor kell Igaz értéket visszaadnia, ha van érvényes zárójeles részsorozat
    ahol a részsorozatban legalább egy szögletes zárójel be van ágyazva.

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

def is_nested(string):
    '''
    Hozzon létre egy függvényt, amely csak szögletes zárójelet tartalmazó karakterláncot vesz be.
    A függvénynek akkor és csak akkor kell True értéket visszaadnia, ha van érvényes zárójelek részsorozata
    ahol az alsorozatban legalább egy zárójel be van ágyazva.

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

def is_nested(string):
    '''
    Hozzon létre egy függvényt, amely bemenetként olyan karakterláncot fogad el,
    amely csak szögletes zárójeleket tartalmaz.
    A függvény akkor és csak akkor adjon vissza True értéket, ha van olyan zárójeleket
     tartalmazó érvényes részsorozat, ahol a részsorozatban legalább egy beágyazott sorozat van.

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


def sum_squares(lst):
    """Adott egy számok listája.
    Vissza kell adni a számok összegét, miután minden elemet
    a listában egész számra kerekítünk és négyzetre emelünk.
    Példa:
    lst = [1,2,3] akkor a kimenetnek 14-nek kell lennie.
    lst = [1,4,9] akkor a kimenetnek 98-nak kell lennie.
    lst = [1,3,5,7] akkor a kimenetnek 84-nek kell lennie.
    lst = [1.4,4.2,0] akkor a kimenetnek 29-nek kell lennie.
    lst = [-2.4,1,1] akkor a kimenetnek 6-nak kell lennie.
    """

def sum_squares(lst):
    """Kapsz egy számlistát.
    Vissza kell adnia a megadott listában szereplő számok négyzetes összegét,
    először kerekítse le a lista minden elemét a felső int (ceiling) felé.
    Példák:
    Ha lst = [1,2,3], az eredménynek 14-nek kell lennie.
    Ha lst = [1,4,9], az eredménynek 98-nak kell lennie.
    Ha lst = [1,3,5,7], az eredménynek 84-nek kell lennie.
    Ha lst = [1.4,4.2,0], az eredménynek 29-nek kell lennie.
    Ha lst = [-2.4,1,1], az eredménynek 6-nak kell lennie.

    """

def sum_squares(lst):
    """Kapsz egy számlistát.
    Vissza kell adnia a négyzetes számok összegét az adott listában,
    kerekítse először a lista minden elemét a felső int(plafon) értékre.
    Példák:
    lst = [1,2,3] esetén a kimenetnek 14-nek kell lennie
    lst = [1,4,9] esetén a kimenetnek 98-nak kell lennie
    lst = [1,3,5,7] esetén a kimenetnek 84-nek kell lennie
    lst = [1.4,4.2,0] esetén a kimenetnek 29-nek kell lennie
    lst = [-2.4,1,1] esetén a kimenetnek 6-nak kell lennie

    """


def check_if_last_char_is_a_letter(txt):
    '''
    Hozz létre egy függvényt, amely True értéket ad vissza, ha
    egy adott karakterlánc utolsó karaktere betű, és nem része
    egy szónak, egyébként pedig False értéket ad vissza.
    Megjegyzés: a "szó" egy szóközzel elválasztott karaktercsoport.

    Példák:
    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):
    '''
    Hozzon létre egy függvényt, amely igazat ad vissza, ha az utolsó karakter
    egy adott karakterlánc alfabetikus karakter, és nem
    egy szó része, és egyébként hamis.
    Megjegyzés: A "szó" szóközzel elválasztott karaktercsoport.

    Példák:
    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):
    '''
    Hozzon létre egy függvényt, amely Igaz értéket ad vissza, ha az utolsó karakter
    egy adott karakterlánc alfabetikus karaktere, és nem
    egy szó része, egyébként pedig hamis.
    Megjegyzés: a "szó" szóközzel elválasztott karakterek csoportja.

    Példák:
    check_if_last_char_is_a_letter("apple pie") ➞ False
    check_if_last_char_is_a_letter("apple pi e") ➞ True
    check_if_last_char_is_a_letter("apple pi e ") ➞ False
    check_if_last_char_is_a_letter("") ➞ False
    '''


def can_arrange(arr):
    """Hozzon létre egy függvényt, amely egy olyan elem legnagyobb indexét adja vissza, amely
    nem nagyobb vagy egyenlő az őt közvetlenül megelőző elemmel. Ha
    nem létezik ilyen elem, akkor adjon vissza -1-et. Az adott tömb nem fog tartalmazni
    duplikált értékek.

    Példák:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Hozz létre egy olyan függvényt, amely visszaadja annak az elemnek a legnagyobb indexét,
    amely nem nagyobb vagy egyenlő az azt közvetlenül megelőző elemnél. Ha nincs ilyen elem,
    akkor -1-et kell visszaadni. A megadott tömb nem tartalmaz ismétlődő értékeket.

    Példák:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """

def can_arrange(arr):
    """Hozzon létre egy függvényt, amely egy olyan elem legnagyobb indexét adja vissza, amely
    nem nagyobb vagy egyenlő az azt közvetlenül megelőző elemmel. Ha
    Nincs ilyen elem, majd adja vissza a -1 értéket. Az adott tömb nem tartalmazza
    ismétlődő értékek.

    Példák:
    can_arrange([1,2,4,3,5]) = 3
    can_arrange([1,2,3]) = -1
    """


def largest_smallest_integers(lst):
    '''
    Hozzon létre egy függvényt, amely egy (a, b) sort ad vissza, ahol „a” van
    a legnagyobb negatív egész szám, a 'b' pedig a legkisebb
    pozitív egész számok közül egy listában.
    Ha nincs negatív vagy pozitív egész szám, adja vissza őket None értékként.

    Példák:
    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):
    '''
    Hozzon létre egy függvényt, amely egy rekordot ad vissza (a, b), ahol az "a"
    a negatív egész számok közül a legnagyobb, a "b" pedig a legkisebb
    pozitív egész számok száma egy listában.
    Ha nincsenek negatív vagy pozitív egész számok, adja vissza őket Nincs értékként.

    Példák:
    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):
    '''
    Függvény, amely egy rendezett értéksort (a, b) ad vissza, ahol
    'a' a legnagyobb negatív egész szám és 'b' a legkisebb
    pozitív egész szám a listában.
    Ha nincs negatív vagy pozitív egész szám, akkor None-t ad vissza.

    Példák:
    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):
    """
    Hozzon létre egy függvényt, amely egész számokat, lebegőpontokat vagy karakterláncokat reprezentál
    valós számokat, és a nagyobb változót adja vissza az adott változótípusban.
    Return None, ha az értékek egyenlőek.
    Megjegyzés: Ha egy valós szám karakterláncként van ábrázolva, a lebegőpont lehet . vagy ,

    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):
    """
    Hozzon létre egy függvényt, amely egész számokat, lebegőpontos értékeket vagy sztringeket képvisel
    valós számok, és visszaadja a nagyobb változót az adott változótípusban.
    Visszatérési érték Nincs Ha az értékek egyenlőek.
    Megjegyzés: Ha egy valós szám karakterláncként van ábrázolva, a lebegőpont lehet . vagy

    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):
    """Határozza meg, hogy a megadott n szám pontosan kifejezhető-e 4 pozitív páros szám összegeként
    Példa
    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):
    """Mérje fel, hogy az adott n szám felírható-e pontosan 4 pozitív páros szám összegeként!
    Példa
    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):
    """Értékelje, hogy az adott n szám felírható-e pontosan 4 pozitív páros szám összegeként
    Példa
    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):
    """A brazil faktoriális definíciója a következő:
    brazilian_factorial(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ahol n > 0

    Például:
    >>> special_factorial(4)
    288

    A függvény bemenetként egy egész számot fogad, és ennek az egész számnak a speciális
    faktoriálisát adja vissza.

    """

def special_factorial(n):
    """A brazil faktoriális meghatározása a következő:
    brazil_faktoriális(n) = n! * (n-1)! * (n-2)! * ... * 1!
    ahol n > 0

    Például:
    >>> special_factorial(4)
    288

    A függvény egy egész számot fog kapni bemenetként, és vissza kell adnia a speciális értéket
    ennek az egész számnak faktoriálisa.
    """

def special_factorial n):
    """A brazil faktoriális definíciója:
    brazilian_factorial(n) = n!  * (n-1)!  * (n-2)!  * ... * 1!
    ahol n > 0

    Például:
    >>> special_factorial(4)
    288

    A függvény bemenetként egész számot kap, és a speciális
    faktoriális ennek az egész számnak.
    """


def fix_spaces(text):
    """
    Adott egy karakterlánc. Cseréld ki az összes szóközt aláhúzásjellel,
    és ha a karakterláncban egymás után több, mint 2 szóköz van,
    akkor az összes egymást követő szóközt cseréld ki egy kötőjellel.

    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):
    """
    Adott egy karakterlánc szövege, cserélje ki az összes szóközt aláhúzásjelekkel,
    és ha egy karakterláncnak több mint 2 egymást követő szóköze van,
    Ezután cserélje ki az összes egymást követő szóközt -

    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):
    """
    Cserélje ki az összes szóközt a megadott szöveges karakterláncban alsókötőjellel,
    és ha a karakterláncban 2 vagy több egymást követő szóköz van,
    cserélje ki az összes egymást követő szóközt kötőjellel.

    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):
    """Hozz létre egy függvényt, amelynek a bemenete egy karakterláncból álló fájlnév, és amely
        'Yes'-t ad vissza, ha a fájlnév érvényes, és 'No'-t minden más esetben.
    A fájlnév akkor és csak akkor tekintendő érvényesnek, ha az összes következő feltétel
    teljesül:
    - A fájlnév legfeljebb három számjegyet tartalmazhat ('0'-'9').
    - A fájlnév pontosan egy pontot '.' tartalmaz.
    - A pont előtti alsztring nem lehet üres, és a latin abc ('a'-'z' és 'A'-'Z') egyik betűjével kezdődik.
    - A pontot követő alsztring a következő sztringek egyike: ['txt', 'exe', 'dll']
    Példák:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (a névnek a latin abc egyik betűjével kell kezdődnie)
    """

def file_name_check(file_name):
    """Hozzon létre egy függvényt, amely egy fájl nevét képviselő karakterláncot vesz fel, és visszatér
    "Yes", ha a fájl neve érvényes, ellenkező esetben pedig "No" értéket ad vissza.
    Egy fájl neve akkor és csak akkor tekinthető érvényesnek, ha az alábbi feltételek mindegyike teljesül
    teljesülnek:
    - A fájl nevében legfeljebb három számjegy ("0"-'9') szerepelhet.
    - A fájl neve pontosan egy pontot tartalmaz '.'
    - A pont előtti alszöveg nem lehet üres, és egy betűvel kezdődik
    a latin alphapet ("a"-"z" és "A"-"Z").
    - A pont utáni alsztringnek ezek egyikének kell lennie: ['txt', 'exe', 'dll']
    Példák:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No'  (a névnek latin alphapet betűvel kell kezdődnie)
    """

def file_name_check(file_name):
    """Hozzon létre egy függvényt, amely egy fájlnevet reprezentáló karakterláncot vesz fel, és visszatér
    'Yes', ha a fájl neve érvényes, és ellenkező esetben 'No' ad vissza.
    A fájl neve akkor és csak akkor tekinthető érvényesnek, ha az alábbi feltételek mindegyike teljesül
    teljesülnek:
    - A fájl nevében nem lehet több három számjegynél ('0'-'9').
    - A fájl neve pontosan egy pontot tartalmaz "."
    - A pont előtti részkarakterlánc nem lehet üres, és a következő betűvel kezdődik
    a latin ábécé ('a'-'z' és 'A'-'Z').
    - A pont utáni karakterlánc a következők egyike lehet: ['txt', 'exe', 'dll']
    Példák:
    file_name_check("example.txt") # => 'Yes'
    file_name_check("1example.dll") # => 'No' (the name should start with a latin alphapet letter)
    """


def sum_squares(lst):
    """"
    Ez a függvény egy egész számokból álló listát vesz fel. A lista minden egyes elemére nézve a függvény négyzetre emeli az adott számot,
    ha annak indexe hárommal osztható, és köbére emeli, ha az indexe néggyel osztható, de nem osztható hárommal.
    A függvény nem változtatja meg azokat az elemeket, amelyek indexei nem oszthatók sem hárommal, sem néggyel.
    A függvény végül visszaadja az összes elem összegét.

    Példák:
    Ha lst = [1,2,3], akkor a kimenet 6 lesz
    Ha lst = [], akkor a kimenet 0 lesz
    Ha lst = [-1,-5,2,-1,-5], akkor a kimenet -126 lesz
    """

def sum_squares(lst):
    """"
    Ez a függvény egész számok listáját veszi fel. A lista összes bejegyzésénél a függvény négyzetre emeli az egész számot, ha indexe a
    3 többszöröse, és köbere emeli az egész számot, ha indexe 4 többszöröse, és nem 3 többszöröse. A függvény nem
    módosítsa azokat a bejegyzéseket a listában, amelyek indexei nem 3 vagy 4 többszörösei. A függvény ezután az összes bejegyzés összegét adja vissza.

    Példák:
    Ha lst = [1,2,3], az eredménynek 6-nak kell lennie.
    Ha lst = [], az eredménynek 0-nak kell lennie.
    Ha lst = [-1,-5,2,-1,-5], az eredménynek -126-nak kell lennie.
    """

def sum_squares(lst):
    """"
    Ez a függvény egész számok listáját veszi fel. A lista összes bejegyzése esetében a függvény négyzetre emeli az egész számot, ha indexe
    3 többszöröse, és kockára teszi az egész szám bejegyzést, ha az indexe 4 többszöröse, és nem a 3 többszöröse. A függvény nem
    Módosítsa a lista azon bejegyzéseit, amelyek tárgymutatója nem a 3 vagy a 4 többszöröse. A függvény ezután az összes tétel összegét adja eredményül.

    Példák:
    lst = [1,2,3] esetén a kimenetnek 6-nak kell lennie
    lst = [] esetén a kimenetnek 0-nak kell lennie
    lst = [-1,-5,2,-1,-5] esetén a kimenetnek -126-nak kell lennie
    """


def words_in_sentence(sentence):
    """
    Adott egy mondat, amely egy karakterláncként van ábrázolva,
    ez a mondat több, szóközökkel elválasztott szót tartalmaz,
    és vissza kell adni egy karakterláncot, amely az eredeti mondatból azokat a szavakat tartalmazza,
    amelyek hossza prímszám,
    az új karakterláncban a szavak sorrendjének meg kell egyeznie az eredeti mondattal.

    Példa 1:
    Bemenet: sentence = "This is a test"
    Kimenet: "is"

    Példa 2:
    Bemenet: sentence = "lets go for swimming"
    Kimenet: "go for"

    Korlátozások:
    * 1 <= len(sentence) <= 100
    * a mondat csak betűket tartalmaz
    """

def words_in_sentence(sentence):
    """
    Kapsz egy karakterláncot, amely egy mondatot jelképez,
    a mondat szóközzel elválasztott szavakat tartalmaz,
    és vissza kell adnia egy karakterláncot, amely tartalmazza az eredeti mondat szavait,
    amelyek hossza prímszámok,
    az új karakterláncban a szavak sorrendje megegyezzen az eredetivel.

    1. példa:
        Input: sentence = "This is a test"
        Output: "is"

    2. példa:
        Input: sentence = "lets go for swimming"
        Output: "go for"

    Korlátozások:
        * 1 <= len(sentence) <= 100
        * sentence contains only letters
    """

def words_in_sentence(sentence):
    """
    Kapsz egy mondatot képviselő karakterláncot,
    a mondat szóközzel elválasztott szavakat tartalmaz,
    és vissza kell adnia egy karakterláncot, amely tartalmazza az eredeti mondat szavait,
    amelyek hossza prímszámok,
    Az új karakterláncban szereplő szavak sorrendjének meg kell egyeznie az eredetivel.

    1. példa:
        Bemenet: sentence = "This is a test"
        Kimenet: "is"

    2. példa:
        Bemenet: sentence = "lets go for
        Kimenet: "go for"

    Korlátok:
        * 1 <= len(sentence) <= 100
        * sentence contains only letters
    """


def simplify(x, n):
    """A feladatod egy olyan függvény implementálása, amely leegyszerűsíti az
    x * n kifejezést. A függvény True értéket ad vissza, ha x * n egész számot eredményez, és False
    egyébként. Mindkét x és n, egy-egy tört szám, és a következő formátumban vannak,
    <számláló>/<nevező>, ahol mindkét számláló és nevező pozitív egész szám.

    Feltételezhetjük, hogy x és n érvényes törtek, és a nevezőjük nem nulla.

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

def simplify(x, n):
    """Az Ön feladata egy olyan függvény megvalósítása, amely egyszerűsíti a kifejezést
    x * n. A függvény Igaz értéket ad vissza, ha x * n egész számot ad vissza, és hamis
    egyébként. Mind az x, mind az n egy tört karakterlánc-ábrázolása, és formátumuk a következő:
    <numerator>/<denominator> ahol mind a számláló, mind a nevező pozitív egész szám.

    Feltételezhetjük, hogy x és n érvényes törtek, és nincs nulla nevezőjük.

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

def simplify(x, n):
    """Az Ön feladata egy olyan függvény megvalósítása, amely leegyszerűsíti a kifejezést
    x * n. A függvény igazat ad vissza, ha x * n egész számot ad vissza, és hamis értéket ad vissza
    egyébként. Mind az x, mind az n egy tört karakterlánc-reprezentációja, és a következő formátumú,
    <numerator>/<denominator> ahol a számláló és a nevező is pozitív egész szám.

    Feltételezheti, hogy x és n érvényes törtek, és nem nulla a nevező.

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


def order_by_points(nums):
    """
    Írj egy függvényt, amely sorba rendezi a megadott egész számok listáját
    növekvő sorrendbe a számjegyeik összegének megfelelően.
    Megjegyzés: ha több elem számjegyeinek összege azonos,
    az eredeti listában elfoglalt indexük alapján kell őket sorrendbe állítani.

    Például:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Írjon egy függvényt, amely rendezi az adott egész számok listáját
    növekvő sorrendben számjegyeik összegének megfelelően.
    Megjegyzés: ha több tétel van hasonló számjegyösszeggel,
    Rendezze őket az eredeti listában szereplő indexük alapján.

    Például:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """

def order_by_points(nums):
    """
    Írjon egy függvényt, amely rendezi az adott egész számok listáját
    számjegyeik összege szerint növekvő sorrendben.
    Megjegyzés: ha több olyan elem is van, amelyek számjegyeinek összege hasonló,
    Rendelje meg őket az eredeti listában szereplő indexük alapján.

    Például:
    >>> order_by_points([1, 11, -1, -11, -12]) == [-1, -11, 1, -12, 11]
    >>> order_by_points([]) == []
    """


def specialFilter(nums):
    """Írj egy olyan függvényt, amelynek bemenete egy számokból álló tömb,
        és amely a tömbben lévő azon elemek számát adja vissza, amelyek nagyobbak,
        mint 10, és amelyek első és utolsó számjegye is páratlan szám (1, 3, 5, 7, 9).
    Például:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Fogadjon el egy számokból álló tömböt bemenetként, és írjon egy függvényt, amely visszaadja a tömb azon elemeinek számát,
    amelyek nagyobbak, mint 10, és mindkét számjegyük, az első és az utolsó is páratlan (1, 3, 5, 7, 9).
    Példa:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """

def specialFilter(nums):
    """Írj egy függvényt, amely egy számokat tartalmazó tömböt kap bemenetként, és visszaadja
    azoknak az elemeknek a számát, amelyek nagyobbak 10-nél, és az adott szám első és utolsó számjegye
    is páratlan (1, 3, 5, 7, 9).
    Például:
    specialFilter([15, -73, 14, -15]) => 1
    specialFilter([33, -2, -3, 45, 21, 109]) => 2
    """


def get_max_triples(n):
    """
    Adott egy pozitív egész szám n. Hozzon létre a egy n hosszúságú egész számokból álló tömböt.
    Minden i (1 ≤ i ≤ n) esetén az a[i] = i * i - i + 1.
    Adja vissza az (a[i], a[j], a[k]) hármasok számát a tömbben, ahol i < j < k.
    És a[i] + a[j] + a[k] osztható 3-mal.

    Példa:
    Bemenet: n = 5
    Kimenet: 1
    Magyarázat:
    a = [1, 3, 7, 13, 21]
    Az egyetlen érvényes hármas (1, 7, 13).
    """

def get_max_triples(n):
    """
    Pozitív egész számot kapsz n. Létre kell hoznia egy n hosszúságú a egész tömböt.
        Minden i (1 ≤ i ≤ n) esetében az a[i] = i * i - i + 1 értéke.
        Számítsa vissza az a hármasainak (a[i], a[j], a[k]) számát, ahol i < j < k,
    és a[i] + a[j] + a[k] a 3 többszöröse.

    Példa:
        Bemenet: n = 5
        Kimenet: 1
        Magyarázat:
        a = [1, 3, 7, 13, 21]
        Az egyetlen érvényes hármas az (1, 7, 13).
    """

def get_max_triples(n):
    """
    Kapsz egy n pozitív egész számot. Létre kell hoznia egy n hosszúságú a egész tömböt.
        Minden i (1 ≤ i ≤ n) esetén a[i] = i * i - i + 1.
        Adja vissza a triplák számát (a[i], a[j], a[k]), ahol i < j < k,
    és a[i] + a[j] + a[k] 3 többszöröse.

    Példa:
        Input: n = 5
        Output: 1
        Magyarázat:
        a = [1, 3, 7, 13, 21]
        Az egyetlen érvényes hármas az (1, 7, 13).
    """


def bf(planet1, planet2):
    '''
    A naprendszerünkben nyolc bolygó van: a Naphoz legközelebb a Merkúr van,
    majd következik a Vénusz, Föld, Mars, Jupiter, Szaturnusz, Uránusz, Neptunusz.
    Írjon egy függvényt, amely két bolygó nevét veszi karakterláncként: planet1 és planet2.
    A függvénynek vissza kell adnia egy rendezett n-est, amely az összes bolygót tartalmazza, amelyek pályái a planet1 és planet2 pályái között találhatók,
    a Naphoz legközelebbi sorrendben rendezve.
    Ha a planet1 vagy a planet2 nem egy helyes bolygónév, adjon vissza egy üres rendezett n-est.
    Példa
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Naprendszerünkben nyolc bolygó található: a legközelebbi a Naphoz
    a Merkúr, a következő a Vénusz, majd a Föld, a Mars, a Jupiter, a Szaturnusz,
    Uránusz, Neptunusz.
    Írjon egy függvényt, amely két bolygónevet veszi fel a planet1 és planet2 karakterláncoknak.
    A függvénynek egy olyan sort kell visszaadnia, amely tartalmazza az összes olyan bolygót, amelyek pályája ilyen
    az 1. bolygó pályája és a 2. bolygó pályája között helyezkedik el, a szerint rendezve
    a nap közelsége.
    A függvénynek üres sort kell visszaadnia, ha planet1 vagy planet2
    nem helyes bolygónevek.
    Példák
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''

def bf(planet1, planet2):
    '''
    Naprendszerünkben nyolc bolygó van: a Naphoz legközelebb eső bolygó
    a Merkúr, a következő a Vénusz, majd a Föld, a Mars, a Jupiter, a Szaturnusz,
    Uránusz, Neptunusz.
    Írjon egy függvényt, amely két bolygónevet vesz fel karakterláncként: bolygó1 és bolygó2.
    A függvénynek egy olyan rekordot kell visszaadnia, amely tartalmazza az összes olyan bolygót, amelynek pályája
    az 1. bolygó pályája és a 2. bolygó pályája között helyezkedik el, a következő szerint rendezve:
    a nap közelsége.
    A függvénynek üres rekordot kell visszaadnia, ha bolygó1 vagy bolygó2
    nem helyes bolygónevek.
    Példák
    bf("Jupiter", "Neptune") ==> ("Saturn", "Uranus")
    bf("Earth", "Mercury") ==> ("Venus")
    bf("Mercury", "Uranus") ==> ("Venus", "Earth", "Mars", "Jupiter", "Saturn")
    '''