def sorted_list_sum(lst):
    """Írjon egy függvényt, amely paraméterként elfogadja a karakterláncok listáját,
    törli belőle a páratlan hosszúságú karakterláncokat,
    és visszaadja az eredményül kapott listát rendezett sorrendben,
    A lista mindig karakterláncok listája, és soha nem számok tömbje,
    és tartalmazhat duplikátumokat.
    A lista sorrendjének az egyes szavak hosszával emelkedőnek kell lennie, és
    vissza kell adnia az adott szabály szerint rendezett listát.
    Ha két szó azonos hosszúságú, rendezze a listát ábécé sorrendbe.
    A függvénynek a karakterláncok listáját kell visszaadnia rendezett sorrendben.
    Feltételezheti, hogy minden szó azonos hosszúságú lesz.
    Például:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Írjon egy függvényt, amely elfogad egy listát paraméterként,
    eltávolítja a páratlan hosszúságú karakterláncokat,
    visszaadja a kapott listát rendezett sorrendben,
    a lista mindig karakterláncok listája, nem pedig egy numerikus tömb, és
    tartalmazhat duplikátumokat.
    A lista sorrendjének növekvőnek kell lennie az egyes szavak hossza szerint,
    és vissza kell adnia azt a listát, amely e szabály szerint van rendezve.
    Ha két szó hossza azonos, rendezze a listát ábécé sorrendben.
    A függvénynek vissza kell adnia a karakterláncok listáját rendezett sorrendben.
    Feltételezheti, hogy az összes szó hossza azonos.
    Példa:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """

def sorted_list_sum(lst):
    """Írjon egy függvényt, amely egy listát fogad paraméterként,
    eltávolítja a páratlan hosszúságú karakterláncokat,
    visszaadja a kapott listát rendezett sorrendben,
    a lista mindig karakterláncok listája, nem pedig numerikus tömb,
    tartalmazhat duplikátumokat.
    A lista sorrendjének növekvőnek kell lennie az egyes szavak hossza szerint,
    és vissza kell adnia a listát, amely e szabály szerint van rendezve.
    Ha két szó hossza azonos, rendezze a listát ábécé sorrendben.
    A függvénynek vissza kell adnia a karakterláncok listáját rendezett sorrendben.
    Feltételezheti, hogy az összes szó hossza azonos.
    Példa:
    assert list_sort(["aa", "a", "aaa"]) => ["aa"]
    assert list_sort(["ab", "a", "aaa", "cd"]) => ["ab", "cd"]
    """


def x_or_y(n, x, y):
    """Egy egyszerű program, amelynek vissza kell adnia x értékét, ha n
    prímszám, ellenkező esetben y értékét kell visszaadnia.

    Példák:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Egy egyszerű program, amelynek vissza kell adnia x értékét, ha n
    prímszám, és ellenkező esetben y értékét kell visszaadnia.

    Példák:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """

def x_or_y(n, x, y):
    """Egy egyszerű program, amely az x értékét adja vissza, ha n egy prímszám,
    és a y értékét adja vissza, ha nem az.

    Példák:
    for x_or_y(7, 34, 12) == 34
    for x_or_y(15, 8, 5) == 5

    """


def double_the_difference(lst):
    '''
    Adott egy számokból álló lista. Vissza kell adnia azokat a számok négyzetének összegét
    a listában, amelyek páratlanok. Hagyja figyelmen kívül a negatív számokat és a nem egész számokat.

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

    Ha az input lista üres, akkor 0-t kell visszaadni.
    '''

def double_the_difference(lst):
    '''
    Adott számlista esetén adja vissza a számok négyzetének összegét
    a listában páratlanok. Hagyja figyelmen kívül a negatív vagy nem egész számokat.

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

    Ha a beviteli lista üres, adja vissza a 0 értéket.
    '''

def double_the_difference(lst):
    '''
    Adott egy számlista, adja vissza a számok négyzetösszegét
    a listában, amelyek páratlanok. Hagyja figyelmen kívül azokat a számokat, amelyek negatívak vagy nem egészek.

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

    Ha a beviteli lista üres, térjen vissza 0-val.
    '''


def compare(game,guess):
    """Azt hiszem, mindannyian emlékszünk arra az érzésre, amikor az eredménye néhány régóta várt
    végre ismertté vált az esemény. Az érzéseid és gondolataid abban a pillanatban vannak
    mindenképpen érdemes lejegyezni és összehasonlítani.
    Az Ön feladata annak megállapítása, hogy egy személy helyesen találta-e ki számos mérkőzés eredményét.
    Két egyenlő hosszúságú pontszámot és találgatást kap, ahol minden index egyezést mutat.
    Egy azonos hosszúságú tömböt ad vissza, jelezve, milyen messze voltak az egyes találgatások. Ha jól sejtették,
    az érték 0, ha nem, az érték a tipp és a pontszám közötti abszolút különbség.

    példa:

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

def compare(game,guess):
    ""Azt hiszem, mindannyian emlékszünk arra az érzésre, amikor egy régóta várt
    Az esemény végre ismert. Az érzéseid és gondolataid abban a pillanatban a következők:
    Határozottan érdemes megjegyezni és összehasonlítani.
    Az Ön feladata annak megállapítása, hogy egy személy helyesen kitalálta-e számos mérkőzés eredményét.
    Két azonos hosszúságú pontszámot és találgatást kap, ahol minden index egyezést mutat.
    Egy azonos hosszúságú tömböt ad vissza, amely jelzi, hogy az egyes találgatások milyen messze voltak. Ha jól sejtették,
    Az érték 0, és ha nem, akkor az érték a becslés és a pontszám közötti abszolút különbség.

    példa:

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

def compare(game,guess):
    """Azt hiszem, mindannyian emlékszünk arra az érzésre, amikor az eredménye néhány régóta várt
    az esemény végre ismert. Az érzéseid és gondolataid abban a pillanatban vannak
    mindenképpen érdemes lejegyezni és összehasonlítani.
    Az Ön feladata annak megállapítása, hogy egy személy helyesen találta-e ki számos mérkőzés eredményét.
    Két egyenlő hosszúságú pontszámot és találgatást kap, ahol minden index egyezést mutat.
    Egy azonos hosszúságú tömböt ad vissza, jelezve, milyen messze voltak az egyes találgatások. Ha jól sejtették,
    az érték 0, ha nem, az érték a tipp és a pontszám közötti abszolút különbség.

    példa:

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


def Strongest_Extension(class_name, extensions):
    """Egy osztály nevét (egy karakterlánc) és egy bővítmények listáját kapod meg.
    A bővítmények az osztályhoz további osztályok betöltésére használhatók.
    A bővítmény erőssége a következőképpen számítható ki: Legyen CAP a bővítmény
    nevében lévő nagybetűk száma, és legyen SM a kisbetűk száma, az erősséget
    az alábbi képlet adja: CAP - SM.
    Meg kell találni a legerősebb bővítményt, és visszaadni egy karakterláncot
    ebben a formátumban: ClassName.StrongestExtensionName.
    Ha két vagy több bővítménynek azonos az erőssége, akkor azt kell választani,
    amelyik előbb van a listában.
    Például, ha a "Slices" osztályt kapod meg, és a bővítmények listája:
    ['SErviNGSliCes', 'Cheese', 'StuFfed'], akkor 'Slices.SErviNGSliCes'-t kell
    visszaadni, mivel 'SErviNGSliCes' a legerősebb bővítmény (az erőssége -1).
    Példa:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Adott egy osztály neve (sztring) és kiterjesztések egy listája.
    A kiterjesztések arra szolgálnak, hogy további osztályokat lehessen az osztályhoz adni.
    A kiterjesztések ereje a következő: Legyen CAP a nagybetűk száma a kiterjesztés
    nevében, és legyen SM a kisbetűk száma a kiterjesztés nevében. Az erő mértéke
    CAP-SM.
    Találd meg a legerősebb kiterjesztést, és adj vissza egy sztringet a
    következő formátumban: ClassName.StrongestExtensionName.
    Ha két vagy több kiterjesztésnek ugyanaz az ereje, akkor azt válaszd,
    amely a listában előbb szerepel.
    Például, ha a megadott osztály "Slices", és a kiterjesztések listája:
    ['SErviNGSliCes', 'Cheese', 'StuFfed'], akkor a visszaadandó érték
    'Slices.SErviNGSliCes', mivel az 'SErviNGSliCes' a legerősebb kiterjesztés
    (azereje -1).
    Példa:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class.AA'
    """

def Strongest_Extension(class_name, extensions):
    """Megkapja egy osztály nevét (karakterláncot) és a kiterjesztések listáját.
    A kiterjesztések további osztályok betöltésére szolgálnak az osztályba. A
    a kiterjesztés erőssége a következő: Legyen CAP a nagybetűk száma
    betűket a kiterjesztés nevében, és legyen SM a kisbetűk száma
    a kiterjesztés nevében az erősséget a CAP - SM frakció adja meg.
    Meg kell találnia a legerősebb kiterjesztést, és vissza kell adnia egy karakterláncot ebben
    formátum: ClassName.StrongestExtensionName.
    Ha két vagy több azonos erősségű kiterjesztés van, akkor
    Válassza ki azt, amelyik az első a listában.
    Például, ha a "Szeletek" osztályt és a
    kiterjesztések: ['SErviNGSliCes', 'Cheese', 'StuFfed'] akkor
    visszatérés "Szeletek.SErviNGSliCes", mivel a "SErviNGSliCes" a legerősebb kiterjesztés
    (erőssége -1).
    Példa:
    for Strongest_Extension('my_class', ['AA', 'Be', 'CC']) == 'my_class. AA'
    """


def cycpattern_check(a), b):
    """2 szót kapsz. Igaz értéket kell visszaadnia, ha a második szó vagy annak bármely forgatása az első szó részsztringje
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Adjon meg két szót. Ha a második szó vagy annak bármely permutációja része az első szónak, akkor True értéket kell visszaadjon.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """

def cycpattern_check(a , b):
    """Adott 2 szó. A visszaadott érték legyen True, ha a második szó vagy annak bármilyen permutációja az első szó részsorozata.
    cycpattern_check("abcd","abd") => False
    cycpattern_check("hello","ell") => True
    cycpattern_check("whassup","psus") => False
    cycpattern_check("abab","baa") => True
    cycpattern_check("efef","eeff") => False
    cycpattern_check("himenss","simen") => True

    """


def even_odd_count(num):
    """Adott egy egész szám. visszaadja a páros és páratlan számjegyek számát.

     Példa:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Ha egy egész számot adunk meg, visszaad egy n-esét, amely tartalmazza a páros és páratlan számjegyek számát.

     Példa:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """

def even_odd_count(num):
    """Adott egy egész szám. Egy rendezett értéksort ad vissza, amely a páros és páratlan számjegyek számát adja vissza.

     Példa:
        even_odd_count(-12) ==> (1, 1)
        even_odd_count(123) ==> (1, 2)
    """


def int_to_mini_roman(number):
    """
    Egy pozitív egész számot kapunk, és annak római számjegy megfelelőjét kell
    visszaadni kisbetűs formában.
    Korlátozások: 1 <= num <= 1000

    Példák:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Adott egy pozitív egész szám, kapjuk meg a római számbeli megfelelőjét karakterláncként,
    és adja vissza kisbetűkkel.
    Korlátozások: 1 <= num <= 1000

    Példák:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """

def int_to_mini_roman(number):
    """
    Adott egy pozitív egész szám, kapja meg a római szám megfelelőjét karakterláncként,
    és kisbetűvel adja vissza.
    Korlátozások: 1 <= szám <= 1000

    Példák:
    >>> int_to_mini_roman(19) == 'xix'
    >>> int_to_mini_roman(152) == 'clii'
    >>> int_to_mini_roman(426) == 'cdxxvi'
    """


def right_angle_triangle(a, b, c):
    '''
    Háromszög három oldalának hossza adott. Adjon vissza True értéket, ha a három oldal
    derékszögű háromszöget alkot, különben False.
    A derékszögű háromszög olyan háromszög, amelyben az egyik szög derékszög vagy
    90 fok.
    Példa:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Tekintettel a háromszög három oldalának hosszára. Igaz értéket ad vissza, ha a három
    az oldalak derékszögű háromszöget alkotnak, egyébként hamis.
    A derékszögű háromszög olyan háromszög, amelyben az egyik szög derékszögű vagy
    90 fok.
    Példa:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''

def right_angle_triangle(a, b, c):
    '''
    Adott egy háromszög három oldalának hossza. Igaz, ha a három
    oldalai derékszögű háromszöget alkotnak, egyébként hamis.
    A derékszögű háromszög olyan háromszög, amelyben az egyik szög derékszögű ill
    90 fok.
    Példa:
    right_angle_triangle(3, 4, 5) == True
    right_angle_triangle(1, 2, 3) == False
    '''


def find_max(words):
    """Írjon egy függvényt, amely elfogadja a karakterláncok listáját.
    A lista különböző szavakat tartalmaz. Adja vissza a szót a maximális számmal
    egyedi karakterekből. Ha több karakterláncnál van maximális számú egyedi
    karaktereket, adja vissza azt, amelyik lexikográfiai sorrendben az első.

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

def find_max(words):
    """Írjon egy függvényt, amely elfogad egy sztringlistát.
    A lista különböző szavakat tartalmaz. Adja vissza azt a szót, amely a legtöbb egyedi karaktert tartalmazza.
    Ha több lánc is tartalmazza a maximum egyedi karakterszámot,
    azt a karakterláncot adja vissza, amelyik előbb jelenik meg ábécé sorrendben.

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

def find_max(words):
    """Írjon egy függvényt, amely elfogadja a karakterláncok listáját.
    A lista különböző szavakat tartalmaz. A maximális számot tartalmazó szó visszaadása
    egyedi karakterek. Ha több karakterlánc rendelkezik az egyedi karakterláncok maximális számával
    karaktereket, adja vissza azt, amelyik lexikográfiai sorrendben az első helyen áll.

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


def eat(number, need, remaining):
    """
    Egy éhes nyúl vagy, aki már megevett egy bizonyos számú répát,
    de most még több répát kell megenned, hogy teljesítsd a napi étkezéseket.
    A függvény visszatér egy tömbbel:
    [ az étkezések után elfogyasztott répák teljes száma,
      az étkezések után megmaradt répák száma ]
    Ha nincs elég megmaradt répa, akkor megeszed az összes megmaradt répát,
    de még mindig éhes maradsz.

    Példák:
    * eat(5, 6, 10) -> [11, 4]
    * eat(4, 8, 9) -> [12, 1]
    * eat(1, 10, 10) -> [11, 0]
    * eat(2, 11, 5) -> [7, 0]

    Változók:
    @number : egész szám
        a répák száma, amelyeket már megettél.
    @need : egész szám
        a répák száma, amelyeket még meg kell enned.
    @remaining : egész szám
        a meglévő készletben lévő megmaradt répák száma.

    Korlátok:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Jó szórakozást! :)
    """

def eat(number, need, remaining):
    """
    Éhes nyúl vagy, és már megettél bizonyos számú sárgarépát,
    de most több sárgarépát kell enned, hogy befejezd a napi étkezést.
    az étkezések után vissza kell adnia egy [ elfogyasztott sárgarépát összesen,
                                    az étkezések után megmaradt sárgarépa száma]
    ha nincs elég sárgarépa, akkor az összes megmaradt sárgarépát megeszed, de éhes leszel.

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

    Változók:
    @number : integer
        az elfogyasztott sárgarépa száma.
    @need : integer
        az a sárgarépák száma, amiket még meg kell enned.
    @remaining : integer
        a készleten lévő maradék sárgarépa mennyisége

    Korlátozás:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Jó szórakozást :)
    """

def eat(number, need, remaining):
    """
    Éhes nyúl vagy, és már megettél egy bizonyos számú sárgarépát,
    De most több sárgarépát kell enni, hogy befejezze a napi étkezést.
    vissza kell adnia egy tömböt [ étkezés után elfogyasztott sárgarépa teljes száma,
                                    az étkezések után maradt sárgarépa száma ]
    Ha nincs elég fennmaradó sárgarépa, akkor az összes fennmaradó sárgarépát megeszi, de még mindig éhes lesz.

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

    Változók:
    @number : egész szám
        az elfogyasztott sárgarépa száma.
    @need : egész szám
        a sárgarépa száma, amit enni kell.
    @remaining : egész szám
        a fennmaradó sárgarépa száma raktáron van

    Erőltet:
    * 0 <= number <= 1000
    * 0 <= need <= 1000
    * 0 <= remaining <= 1000

    Jó szórakozást :)
    """


def do_algebra(operator, operand):
    """
    Adott két lista: egy `operator` és egy `operand`. Az első lista alapvető algebrai műveleteket tartalmaz,
    a második lista egész számok listája. Használja a megadott két listát egy algebrai kifejezés felépítéséhez,
    majd térjen vissza a kifejezés értékelésének eredményével.

    Az alapvető algebrai műveletek:
    Összeadás ( + )
    Kivonás ( - )
    Szorzás ( * )
    Egész osztás ( // )
    Hatványozás ( ** )

    Példa:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Megjegyzés:
    Az operator lista hossza eggyel kisebb, mint az operand lista hossza.
    Az operand lista nemnegatív egész számokból áll.
    Az operator lista legalább egy operátort tartalmaz, és az operand lista legalább két operandust tartalmaz.

    """

def do_algebra(operator, operand):
    """
    Adott két listaoperátor és operandus. Az első lista alapvető algebrai műveleteket tartalmaz, és
    A második lista egész számok listája. Használja a két megadott listát az algebrica felépítéséhez
    kifejezést, és adja vissza a kifejezés kiértékelését.

    Az alapvető algebrai műveletek:
    Összeadás ( + )
    Kivonás ( - )
    Szorzás ( * )
    Padlóosztás ( )
    Hatványozás ( ** )

    Példa:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Jegyzet:
        Az operátorlista hossza megegyezik az operanduslista hossza mínusz eggyel.
        Az operandus a nem negatív egész számok listája.
        Az operátorlista legalább egy operátorral rendelkezik, az operanduslista pedig legalább két operandust.

    """

def do_algebra(operator, operand):
    """
    Adott két lista: operátorok és operandusok. Az első listában alapvető algebrai műveletek szerepelnek,
    a második listában pedig egész számok. A két listát algebrai kifejezés létrehozására használd,
    a visszaadott érték pedig legyen a kifejezés értéke.

    Alapvető algebrai műveletek:
    Összeadás ( + )
    Kivonás ( - )
    Szorzás ( * )
    Osztás ( // )
    Hatványozás ( ** )

    Példa:
    operator['+', '*', '-']
    array = [2, 3, 4, 5]
    result = 2 + 3 * 4 - 5
    => result = 9

    Megjegyzés:
         Az operátorok listájának hossza eggyel kisebb, mint az operandusok listája.
         Az operandusok listája nem negatív egész számokból áll.
         Az operátorok listája legalább egy operátort tartalmaz, és az operandusok listája legalább két operandust.

    """


def solve(s):
    """A bemenet egy s karakterlánc.
    Ha s[i] betű, akkor kisbetűről alakítsd át nagybetűre, és fordítva,
    különben hagyd változatlanul.
    Ha a karakterlánc nem tartalmaz betűt, akkor fordítsd meg a karakterláncot.
    A függvénynek az eredményként kapott karakterláncot kell visszaadnia.
    Példák
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Kapsz egy s karakterláncot.
    ha az s[i] betű, fordítsuk meg a kis- és nagybetűket alsóról felsőre, vagy fordítva,
    ellenkező esetben tartsa úgy, ahogy van.
    Ha a karakterlánc nem tartalmaz betűket, fordítsa meg a karakterláncot.
    A függvénynek vissza kell adnia az eredményül kapott sztringet.
    Példák
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """

def solve(s):
    """Kapsz egy s karakterláncot.
    ha s[i] egy betű, fordítsa meg a kis- és nagybetűket alsóról felsőre, vagy fordítva,
    különben maradjon úgy ahogy van.
    Ha a karakterlánc nem tartalmaz betűket, fordítsa meg a karakterláncot.
    A függvénynek vissza kell adnia a kapott karakterláncot.
    Példák
    solve("1234") = "4321"
    solve("ab") = "AB"
    solve("#a@C") = "#A@c"
    """


def string_to_md5(text):
    """
    A megadott 'text' karakterlánchoz, adja vissza annak md5 hash értékű karakterláncát.
    Ha a 'text' egy üres karakterlánc, akkor None értéket adjon vissza.

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

def string_to_md5(text):
    """
    Adott egy szövegként meggadott szstring, adja vissza az md5 hash egyenértékű karakterláncát.
    Ha a "szöveg" üres karakterlánc, visszatérés None.

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

def string_to_md5(text):
    """
    Adott egy "szöveg" karakterlánc, adja vissza az md5 hash megfelelő karakterláncot.
    Ha a "szöveg" egy üres karakterlánc, adja vissza a None értéket.

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


def generate_integers(a, b):
    """
    Adott két pozitív egész szám, a és b, adja vissza az a és b közötti páros számokat,
    növekvő sorrendben.

    Például:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

"""
k
def generate_integers(a, b):
    """
    Két pozitív egész szám, a és b esetén adja vissza a páros számokat a és b között növekvő sorrendben.

    Példa:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """

def generate_integers(a, b):
    """
    Kapsz két pozitív egész számot: a és b. Add vissza az a és b közé eső páros számokat növekvő sorrendben.

    Példa:
    generate_integers(2, 8) => [2, 4, 6, 8]
    generate_integers(8, 2) => [2, 4, 6, 8]
    generate_integers(10, 14) => []
    """