from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Ellenőrizze, hogy az adott számlistában van-e két szám közelebb egymáshoz, mint
    adott küszöbérték.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Ellenőrzi, hogy az adott számok listájában van-e két szám, amelyek
    közelebb vannak egymáshoz, mint az adott küszöbérték.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """

from typing import List

def has_close_elements(numbers: List[float], threshold: float) -> bool:
    """ Ellenőrizd, hogy adott számlistában létezik-e két olyan szám, amely a megadott köszöbértéknél közelebb van egymáshoz.
    >>> has_close_elements([1.0, 2.0, 3.0], 0.5)
    False
    >>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
    True
    """


from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ A függvény bemenete egy olyan karakterlánc, amely több csoportba ágyazott zárójeleket tartalmaz.
    A cél az, hogy ezeket a csoportokat külön-külön karakterláncokká válasszuk, és visszaadjuk azok listáját.
    A különálló csoportok kiegyensúlyozottak (minden nyitó zárójel megfelelően záródik), és nem ágyazódnak egymásba.
    A bemeneti karakterláncban található szóközöket hagyja figyelmen kívül.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> Lista[str]:
    """ A függvény bemenete egy sztring, amely több, beágyazott zárójelcsoportot tartalmaz. A cél az, hogy
    Válassza szét ezeket a csoportokat külön karakterláncokra, és adja vissza ezek listáját.
    A különálló csoportok kiegyensúlyozottak (minden nyitott kapcsos zárójel megfelelően zárt), és nincsenek egymásba ágyazva
    Hagyja figyelmen kívül a bemeneti sztring szóközeit.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """

from typing import List

def separate_paren_groups(paren_string: str) -> List[str]:
    """ A függvény bemenete egy karakterlánc, amely több csoport egymásba ágyazott zárójelet tartalmaz. A célod
    az, hogy ezeket a csoportokat több külön karakterláncba csoportosítsd, és ezek listáját add vissza.
    A külön csoportok legyenek kiegyensúlyozottak (minden nyitó zárójelnek legyen záró párja), és ne legyenek egymásba ágyazva.
    A bemeneti karakterláncban lévő szóközöket hagyd figyelmen kívül.
    >>> separate_paren_groups('( ) (( )) (( )( ))')
    ['()', '(())', '(()())']
    """


def truncate_number(number: float) -> float:
    """ Adott egy pozitív lebegőpontos szám, akkor felbontható
    és egész rész (az adott számnál kisebb legnagyobb egész szám) és tizedesjegyek
    (a maradék rész mindig kisebb, mint 1).

    A szám tizedes törtrészét adja eredményül.
    >>> truncate_number(3.5)
    0.5
    """

def truncate_number(number: float) -> float:
    """ Adott egy pozitív lebegőpontos szám, felbontható
    és egész rész (a megadott számnál kisebb egész szám) és tizedesjegyek
    (a maradék rész mindig kisebb, mint 1).

    A szám tizedes részét adja vissza.
    >>> truncate_number(3.5)
    0.5
    """


from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Megkapja a befizetési és kifizetési műveletek listáját egy bankszámlán, amely a következővel kezdődik
    nulla egyenleg. Az Ön feladata annak észlelése, hogy a számlaegyenleg bármely ponton nulla alá esik-e, és
    ezen a ponton a függvénynek True értéket kell visszaadnia. Ellenkező esetben False-t kell visszaadnia.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Adott egy bankszámlára vonatkozó befizetéseket és kifizetéseket tartalmazó lista, amelynek a kiinduló egyenlege nulla.
    A feladatod annak megállapítása, hogy a számlaegyenleg bármikor nulla alá csökken-e. Ennél a pontnál a függvény Igaz
    értéket adjon vissza, a többi esetben Hamis értéket.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """

from typing import List

def below_zero(operations: List[int]) -> bool:
    """ Kap egy listát a befizetési és kifizetési műveletekről egy bankszámlán, amely a következővel kezdődik:
    nulla egyenleg. Az Ön feladata annak észlelése, hogy a számlaegyenleg bármikor nulla alá esik-e, és
    ezen a ponton a függvénynek True értéket kell visszaadnia. Ellenkező esetben hamis értéket kell visszaadnia.
    >>> below_zero([1, 2, 3])
    False
    >>> below_zero([1, 2, -4, 5])
    True
    """


from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """Adott számok listájára számítsa ki az átlagos abszolút eltérést
    az adathalmaz középértéke körül.
    Az átlagos abszolút eltérés az átlagos abszolút különbség minden egyes
    elem és a középérték (jelen esetben az átlag) között:
    MAD = átlag | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ A bemeneti számok adott listájához számítsa ki az átlagos abszolút eltérést
    ennek az adathalmaznak az átlaga körül.
    Az átlagos abszolút eltérés az egyes típusok közötti átlagos abszolút különbség
    elem és egy középpont (jelen esetben értendő):
    MAD = average | x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """

from typing import List

def mean_absolute_deviation(numbers: List[float]) -> float:
    """ A bemeneti számok adott listájához számítsa ki az átlagos abszolút eltérést
    az adatkészlet átlaga körül.
    Az átlagos abszolút eltérés az egyes országok közötti átlagos abszolút különbség
    elem és egy középpont (ebben az esetben átlag):
    MAD = average |  x - x_mean |
    >>> mean_absolute_deviation([1.0, 2.0, 3.0, 4.0])
    1.0
    """


from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Beszúrja a 'delimeter' számot a megadott `numbers` lista két egymást követő eleme közé.
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """

from typing import List

def intersperse(numbers: List[int], delimeter: int) -> List[int]:
    """ Helyezzen be egy 'delimeter' számot a `numbers' lista minden két egymást követő eleme közé.
    >>> intersperse([], 4)
    []
    >>> intersperse([1, 2, 3], 4)
    [1, 4, 2, 4, 3]
    """


from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ Ennek a függvénynek a bemenete egy karakterlánc, amely több, szóközzel elválasztott zárójeles csoportot tartalmaz.
    Minden egyes csoportra adja vissza a zárójelek legmélyebb beágyazási szintjét.
    Például: (()()) maximálisan két szint mélységű beágyazást tartalmaz, míg ((())) három szintűt.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ A függvény bemenete egy karakterlánc, amely több, szóközzel elválasztott, egymásba ágyazott zárójelek csoportját képviseli.
    Mindegyik csoporthoz, adja vissza a zárójelek legmélyebb beágyazási szintjét.
    Például: (()()) legfeljebb két szintű beágyazást tartalmaz, míg a ((())) három szintű beágyazást.

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

from typing import List

def parse_nested_parens(paren_string: str) -> List[int]:
    """ A függvény bemenete egy sztring, amely több csoportot képvisel a szóközökkel elválasztott beágyazott zárójelekhez.
    Minden csoport esetében adja ki a zárójelek legmélyebb beágyazási szintjét.
    Például ((()()) legfeljebb két fészkelési szinttel rendelkezik, míg (((())) három.

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


from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Szűrje meg a bemeneti karakterláncok listáját úgy, hogy csak azokat tartalmazza, amelyek tartalmazzák
    a megadott részszöveget.
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ A karakterláncok bemeneti listájának szűrése csak azokra, amelyek adott részsztringet tartalmaznak
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """

from typing import List

def filter_by_substring(strings: List[str], substring: str) -> List[str]:
    """ Szűrje a bemeneti karakterláncok listáját csak az adott részkarakterláncot tartalmazó karakterláncokra
    >>> filter_by_substring([], 'a')
    []
    >>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
    ['abc', 'bacd', 'array']
    """


from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """Adott egész számok listája esetén térjen vissza egy olyan tuple-lal,
    amely tartalmazza az összegüket és a szorzatukat.
    Üres lista esetén az összeg 0, a szorzat 1.

    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Az egész számok adott listájához adjon vissza egy rekordot, amely egy lista összes egész számának összegéből és szorzatából áll.
    Az üres összegnek 0-nak, az üres terméknek pedig 1-nek kell lennie.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """

from typing import List, Tuple

def sum_product(numbers: List[int]) -> Tuple[int, int]:
    """ Egy adott egész számlistához adjon vissza egy sort, amely egy lista összes egész számának összegéből és szorzatából áll.
    Az üres összeg 0, az üres termék pedig 1 legyen.
    >>> sum_product([])
    (0, 1)
    >>> sum_product([1, 2, 3, 4])
    (10, 24)
    """


from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Az egész számok adott listájából generálja az adott pillanatig talált gördülő maximális elem listáját
    a sorrendben.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """

from typing import List, Tuple

def rolling_max(numbers: List[int]) -> List[int]:
    """ Az egész számok adott listájából állítsa elő az adott pillanatig talált gördülő maximális elemek listáját
    a sorrendben.
    >>> rolling_max([1, 2, 3, 2, 3, 4, 2])
    [1, 2, 3, 3, 3, 4, 4]
    """


def is_palindrome(string: str) -> bool:
    """ Ellenőrizze, hogy a megadott karakterlánc palindróma-e """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Keresse meg a legrövidebb palindrómát, amely a megadott karakterlánccal kezdődik.
    Az algoritmus ötlete egyszerű:
    - Keresse meg a megadott karakterlánc leghosszabb olyan utótagját, amely palindróma.
    - Adja hozzá a karakterlánc végéhez a palindróm utótag előtt álló előtag fordítottját.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Tesztelje, hogy az adott karakterlánc palindrom-e """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Keresse meg a legrövidebb palindromot, amely egy mellékelt karakterlánccal kezdődik.
    Az algoritmus ötlete egyszerű:
    - Keresse meg a mellékelt karakterlánc leghosszabb utófixét, amely palindrom.
    - A palindrom utótag elé kerülő karakterlánc-előtag hozzáfűzése a karakterlánc végéhez.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """

def is_palindrome(string: str) -> bool:
    """ Ellenőrizze, hogy az adott karakterlánc palindrom-e """
    return string == string[::-1]

def make_palindrome(string: str) -> str:
    """ Keresse meg a legrövidebb palindromot, amely egy mellékelt karakterlánccal kezdődik.
    Az algoritmus ötlete egyszerű:
    - Keresse meg a mellékelt karakterlánc leghosszabb utótagját, amely egy palindrom.
    - Fűzze hozzá a palindrom utótag előtti karakterlánc-előtag karakterlánc-fordítottjának végéhez.
    >>> make_palindrome('')
    ''
    >>> make_palindrome('cat')
    'catac'
    >>> make_palindrome('cata')
    'catac'
    """


from typing import List

def string_xor(a: str, b: str) -> str:
    """A bemenet két karakterlánc – a és b –, amelyek csak 1-eket és 0-kat tartalmaznak.
    Végezz XOR bináris műveletet ezeken a bemeneteken, és az eredményt is karakterlánc formájában add vissza.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ A bemenet két olyan karakterlánc, a és b, amelyek csak 1-eseket és 0-ásokat tartalmaznak.
    Végezze el a bináris XOR műveletet ezeken a bemeneteken, és adja vissza az eredményt szintén karakterláncként.
    >>> string_xor('010', '110')
    '100'
    """

from typing import List

def string_xor(a: str, b: str) -> str:
    """ A bemenet két a és b karakterlánc, amelyek csak 1-ekből és 0-kból állnak.
    Bináris XOR végrehajtása ezeken a bemeneteken, és az eredményt sztringként is visszaadja.
    >>> string_xor('010', '110')
    '100'
    """


from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ Egy karakterláncokból álló listából visszaadja a leghosszabbat. Több azonos hosszúságú
    karakterlánc esetén az elsőt adja vissza. Üres lista esetén None értéket ad vissza.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ A karakterláncok listájából adja vissza a leghosszabbat. Többszörös esetén adja vissza az elsőt
    azonos hosszúságú karakterláncok. Visszaadja None-t abban az esetben, ha a beviteli lista üres.
    >>> longest([])

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

from typing import List, Optional

def longest(strings: List[str]) -> Optional[str]:
    """ A karakterláncok listáján kívül adja vissza a leghosszabbat. Több esetén küldje vissza az elsőt
    azonos hosszúságú húrok. Return None, ha a beviteli lista üres.
    >>> longest([])

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


def greatest_common_divisor(a: int, b: int) -> int:
    """ Adja vissza két egész szám, a és b legnagyobb közös osztóját.
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Két a és b egész szám legnagyobb közös osztóját adja eredményül
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """

def greatest_common_divisor(a: int, b: int) -> int:
    """ Két a és b legnagyobb közös osztóját adja eredményül
    >>> greatest_common_divisor(3, 5)
    1
    >>> greatest_common_divisor(25, 15)
    5
    """


from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Adja vissza a megadott karakterlánc összes előtag listáját a legrövidebbtől a leghosszabbig.
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Az összes előtag listája a bemeneti karakterlánc legrövidebbétől a leghosszabbig
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """

from typing import List

def all_prefixes(string: str) -> List[str]:
    """ Az összes előtag visszatérési listája a bemeneti karakterlánc legrövidebbjétől leghosszabbig
    >>> all_prefixes('abc')
    ['a', 'ab', 'abc']
    """


def string_sequence(n: int) -> str:
    """ Visszaad egy olyan karakterláncot, amely szóközökkel elválasztott számokat tartalmaz 0-tól n-ig, beleértve n-t is.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Egy szóközzel tagolt számokat tartalmazó karakterláncot ad vissza, 0-tól n igzárólag.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """

def string_sequence(n: int) -> str:
    """ Adjon vissza egy karakterláncot, amely 0-tól n-ig terjedő számokat tartalmaz, szóközzel elválasztva.
    >>> string_sequence(0)
    '0'
    >>> string_sequence(5)
    '0 1 2 3 4 5'
    """


def count_distinct_characters(string: str) -> int:
    """ Adott karakterlánc alapján derítse ki, hogy hány különböző karakterből áll (kis- és nagybetűktől függetlenül)
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """Határozd meg, hogy hány különböző karaktert tartalmaz egy adott karakterlánc (a kis- és nagybetűket nem kell megkülönböztetni)
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """

def count_distinct_characters(string: str) -> int:
    """Egy adott szövegben határozza meg, hány különböző karakter található (kis- és nagybetűk nem számítanak különbözőnek).
    >>> count_distinct_characters('xyzXYZ')
    3
    >>> count_distinct_characters('Jerry')
    4
    """


from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Ennek a függvénynek a bemenete egy karakterlánc, amely speciális ASCII formátumban zenei
    hangjegyeket ábrázol. A feladat az, hogy elemezze ezt a karakterláncot, és térjen vissza egy
    egész számokat tartalmazó listával, amely megmutatja, hogy az egyes hangjegyek hány ütemig tartanak.

    Íme a legendája:
    'o' - egész hangjegy, 4 ütemig tart
    'o|' - fél hangjegy, 2 ütemig tart
    '.|' - negyed hangjegy, 1 ütemig tart

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Ennek a funkciónak a bemenete egy karakterlánc, amely speciális ASCII formátumú zenei jegyzeteket képvisel.
    A feladat ennek a sztringnek az elemzése, és az egész számok listájának visszaadása annak megfelelően, hogy hány ütést csinál
    nem utolsósorban.

    Íme egy legenda:
    'o' - egész hang, négy ütésig tart
    'o|' - félhang, két ütésig tart
    '.|' - negyedhang, egy ütésig tart

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

from typing import List

def parse_music(music_string: str) -> List[int]:
    """ Ennek a funkciónak a bemenete egy hangjegyeket reprezentáló karakterlánc egy speciális ASCII formátumban.
    Az Ön feladata, hogy elemezze ezt a karakterláncot, és adja vissza az egyes ütemek számának megfelelő egész számok listáját
    nem utolsó.

    Íme egy legenda:
    'o' – egész hang, négy ütemig tart
    'o|' - fél hang, két ütemig tart
    '.|' - négyes hang, egy ütemig tart

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


def how_many_times(string: str, substring: str) -> int:
    """ Keresse meg, hogy egy adott részkarakterlánc hányszor található meg az eredeti karakterláncban. Számolja az átfedő eseteket.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Határozd meg, hogy egy adott alsztring hányszor szerepel az eredeti karakterláncban.
    Az egymást átfedő eseteket is számold bele.

    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """

def how_many_times(string: str, substring: str) -> int:
    """ Keresse meg, hogy egy adott részkarakterlánc hányszor található meg az eredeti karakterláncban. Számolja meg az egymást átfedő eseteket.
    >>> how_many_times('', 'a')
    0
    >>> how_many_times('aaa', 'a')
    3
    >>> how_many_times('aaaa', 'aa')
    3
    """


from typing import List

def sort_numbers(numbers: str) -> str:
    """ A bemenet számokból álló, szóközzel tagolt karakterlánc "nullától" "kilencig".
    Az érvényes választási lehetőségek: "nulla", "egy", "kettő", "három", "négy", "öt", "hat", "hét", "nyolc" és "kilenc".
    A számokat a legkisebbtől a legnagyobbig rendezve adja vissza
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ A bemenet egy számokat tartalmazó karakterlánc 'zero'-tól 'nine'-ig, szóközzel elválasztva.
    Érvényes lehetőségek: 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'.
    Adja vissza a karakterláncot, úgy hogy a számokat növekvő sorrendben tartalmazza
    >>> sort_numbers('three one five')
    'one three five'
    """

from typing import List

def sort_numbers(numbers: str) -> str:
    """ A bemenet egy szóközzel elválasztott számsor „nulla” és „kilenc” között.
    Az érvényes választási lehetőségek a következők: „nulla”, „egy”, „kettő”, „három”, „négy”, „öt”, „hat”, „hét”, „nyolc” és „kilenc”.
    Adja vissza a karakterláncot a legkisebbtől a legnagyobbig rendezett számokkal
    >>> sort_numbers('three one five')
    'one three five'
    """


from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ Egy adott számlistából (amely legalább két elemből áll) válassza ki és adja vissza azt a kettőt,
    amelyek a legközelebb vannak egymáshoz, és adja vissza őket sorrendben (kisebb szám, nagyobb szám).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """A mellékelt (legalább kettő hosszúságú) számlistából válasszon ki kettőt, amelyek a legközelebb állnak egymáshoz, és adja vissza őket sorrendben (kisebb szám, nagyobb szám).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """

from typing import List, Tuple

def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
    """ A megadott számlistából (amelynek hossza legalább kettő) válassza ki és adja vissza az egymáshoz legközelebb eső kettőt
    egyéb és sorrendben adja vissza őket (kisebb szám, nagyobb szám).
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.2])
    (2.0, 2.2)
    >>> find_closest_elements([1.0, 2.0, 3.0, 4.0, 5.0, 2.0])
    (2.0, 2.0)
    """


from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Egy számokból álló listát kapva (legalább két elemmel), végezz lineáris transzformációt ezen a listán,
    úgy, hogy a legkisebb szám 0 lesz, a legnagyobb pedig 1.
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Adott (legalább két elemből álló) számlista esetén alkalmazzon lineáris transzformációt erre a listára,
    úgy, hogy a legkisebb szám 0 lesz, a legnagyobb pedig 1
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """

from typing import List

def rescale_to_unit(numbers: List[float]) -> List[float]:
    """ Adott számlista (legalább két elemből), alkalmazzon lineáris transzformációt erre a listára,
    úgy, hogy a legkisebb számból 0, a legnagyobbból pedig 1 lesz
    >>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
    [0.0, 0.25, 0.5, 0.75, 1.0]
    """


from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:

    """ Bármely python értékek adott listájának szűrése csak egész számokra
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """

from typing import List, Any

def filter_integers(values: List[Any]) -> List[int]:
    """ A Python értékek adott listáját csak egész számokra szűrheti
    >>> filter_integers(['a', 3.14, 5])
    [5]
    >>> filter_integers([1, 2, 3, 'abc', {}, []])
    [1, 2, 3]
    """


def strlen(string: str) -> int:
    """ Adja vissza a megadott sztring hosszát
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Adott karakterlánc visszatérési hossza
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """

def strlen(string: str) -> int:
    """ Adja vissza a megadott karakterlánc hosszát
    >>> strlen('')
    0
    >>> strlen('abc')
    3
    """


def largest_divisor(n: int) -> int:
    """ Adott n számhoz találja meg a legnagyobb olyan számot, amely pontosan osztja n-t, de kisebb nála.
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Adott n. Találd meg n legnagyobb osztóját, ami kisebb, mint n.
    >>> largest_divisor(15)
    5
    """

def largest_divisor(n: int) -> int:
    """ Egy adott n számhoz keresse meg a legnagyobb számot, amely egyenletesen osztja n-t, kisebb, mint n
    >>> largest_divisor(15)
    5
    """


from typing import List

def factorize(n: int) -> List[int]:
    """ Az adott egész szám prímtényezőinek visszatérési listája a legkisebbtől a legnagyobbig terjedő sorrendben.
    Mindegyik tényezőt fel kell sorolni annyiszor, hogy hányszor jelenik meg a faktorizációban.
    A bemeneti számnak meg kell egyeznie az összes tényező szorzatával
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """

from typing import List

def factorize(n: int) -> List[int]:
    """ Adott egész szám prímtényezőinek visszatérési listája a legkisebbtől a legnagyobbig.
    Mindegyik faktort annyiszor kell felsorolni, hogy hányszor jelenik meg a faktorizálásban.
    A bemeneti számnak egyenlőnek kell lennie az összes tényező szorzatával
    >>> factorize(8)
    [2, 2, 2]
    >>> factorize(25)
    [5, 5]
    >>> factorize(70)
    [2, 5, 7]
    """


from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Az egész számok listájából távolíts el minden elemet, amely több, mint egyszer szerepel.
    A megmaradó elemek sorrendje egyezzen meg a bemenetben lévő sorrenddel.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Az egész számok listájából távolítsa el az összes olyan elemet, amely egynél többször fordul elő.
    Tartsa az elemek sorrendjét ugyanúgy, mint a bemeneten.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """

from typing import List

def remove_duplicates(numbers: List[int]) -> List[int]:
    """ Az egész számok listájából távolítsa el az összes többször előforduló elemet.
    Tartsa az elemek sorrendjét a bemeneti sorrendben.
    >>> remove_duplicates([1, 2, 3, 2, 4])
    [1, 3, 4]
    """


def flip_case(string: str) -> str:
    """ Egy adott karakterlánc esetén fordítsa a kisbetűket nagybetűsre, a nagybetűket pedig kisbetűkre.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Egy adott karakterlánc esetén, alakítsa a kisbetűket nagybetűkké és a nagybetűket kisbetűkké.
    >>> flip_case('Hello')
    'hELLO'
    """

def flip_case(string: str) -> str:
    """ Adott karakterlánc esetén fordítsa át a kisbetűs karaktereket nagybetűkre és a nagybetűket kisbetűkre.
    >>> flip_case('Hello')
    'hELLO'
    """


from typing import List

def concatenate(strings: List[str]) -> str:
    """ A karakterláncok listájának összefűzése egyetlen karakterláncba
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """

from typing import List

def concatenate(strings: List[str]) -> str:
    """ Karakterláncok listájának összefűzése egyetlen karakterlánccá
    >>> concatenate([])
    ''
    >>> concatenate(['a', 'b', 'c'])
    'abc'
    """


from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ A karakterláncok bemeneti listáját csak azokra szűrheti, amelyek egy adott előtaggal kezdődnek.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """

from typing import List

def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
    """ A karakterláncok bemeneti listáját csak az adott előtaggal kezdődő karakterláncokra szűrheti.
    >>> filter_by_prefix([], 'a')
    []
    >>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
    ['abc', 'array']
    """


def get_positive(l: list):
    """Csak a listában szereplő pozitív számokat adja vissza.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: lista):
    ""Csak pozitív számokat adjon vissza a listában.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """

def get_positive(l: list):
    """Csak pozitív számokat adjon vissza a listában.
    >>> get_positive([-1, 2, -4, 5, 6])
    [2, 5, 6]
    >>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    [5, 3, 2, 3, 9, 123, 1]
    """


def is_prime(n):
    """True értéket adjon vissza, ha a megadott szám prímszám, különben False értéket.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Igazat ad vissza, ha egy adott szám prím, és hamis értéket egyébként.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """

def is_prime(n):
    """Visszatérés igaz, ha egy adott szám prím, és hamis egyébként.
    >>> is_prime(6)
    False
    >>> is_prime(101)
    True
    >>> is_prime(11)
    True
    >>> is_prime(13441)
    True
    >>> is_prime(61)
    True
    >>> is_prime(4)
    False
    >>> is_prime(1)
    False
    """


import math

def poly(xs: list, x: float):
    """
    Kiértékel egy polinomot, amelynek együtthatói xs, az x pontban.
    visszatérési érték: xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs egy polinom együtthatóit tartalmazza.
    A find_zero olyan x értéket keres, amelyre poly(x) = 0.
    A find_zero csak egyetlen nullahelyet ad vissza, még akkor is, ha több is van.
    Emellett a find_zero csak olyan xs listát fogad el, amely páros számú együtthatót tartalmaz,
    és a legnagyobb nem nulla együttható biztosítja a megoldás létezését.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Kiértékeli az xs együtthatós polinomot az x pontban.
    return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs egy polinom együtthatói.
    nulla_keresése x keresse meg úgy, hogy poli(x) = 0.
    A find_zero csak nulla pontot ad vissza, még akkor is, ha sok van.
    Ráadásul a find_zero csak páros számú együtthatóval rendelkező xs listát vesz fel
    és a legnagyobb nem nulla együttható, amit garantál
    megoldást.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """

import math

def poly(xs: list, x: float):
    """
    Kiértékeli az xs együtthatójú polinomot az x pontban.
    return xs[0] + xs[1] * x + xs[1] * x^2 + ....  xs[n] * x^n
    """
    return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])

def find_zero(xs: list):
    """ xs egy polinom együtthatói.
    find_zero úgy találjuk meg x-et, hogy poly(x) = 0.
    find_zero csak nulla pontot ad vissza, még akkor is, ha sok van.
    Sőt, find_zero csak páros számú együtthatóval rendelkező x-ek listáját veszi fel
    és a legnagyobb nem nulla együttható, mivel garantálja
    megoldás.
    >>> round(find_zero([1, 2]), 2) # f(x) = 1 + 2x
    -0.5
    >>> round(find_zero([-6, 11, -6, 1]), 2) # (x - 1) * (x - 2) * (x - 3) = -6 + 11x - 6x^2 + x^3
    1.0
    """


def sort_third(l: list):
    """Ez a függvény egy l listát vesz be, és egy l' listát ad vissza úgy, hogy
    l' azonos l-lel azokban az indexekben, amelyek nem oszthatók hárommal, míg azok az indexek, amelyek oszthatók hárommal,
    az l megfelelő indexeinek értékeivel egyeznek, de rendezetten.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Ez a függvény egy l listát vesz fel, és egy l' listát ad vissza úgy, hogy
    l' megegyezik l-vel a hárommal nem osztható indexekben, míg értéke a hárommal osztható indexeknél egyenlő
    l megfelelő indexeinek értékeihez, de rendezve.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """

def sort_third(l: list):
    """Ez a függvény vesz egy l listát, és visszaad egy l' listát úgy, hogy
    l' azonos l-lel azokban az indexekben, amelyek nem oszthatók hárommal, míg értékei a hárommal osztható indexekben egyenlőek
    az l megfelelő indexeinek értékeihez, de rendezve.
    >>> sort_third([1, 2, 3])
    [1, 2, 3]
    >>> sort_third([5, 6, 3, 4, 8, 9, 2])
    [2, 6, 3, 4, 8, 9, 5]
    """


def unique(l: list):
    """Rendezett egyedi elemek visszaadása egy listában
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """A listában lévő egyedi elemeket adja vissza rendezve
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """

def unique(l: list):
    """Rendezett egyedi elemek megjelenítése egy listában
    >>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [0, 2, 3, 5, 9, 123]
    """


def max_element(l: list):
    """Adja vissza a lista legnagyobb elemét.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """Maximális elem visszaadása a listában.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """

def max_element(l: list):
    """Adja vissza a maximális elemet a listában.
    >>> max_element([1, 2, 3])
    3
    >>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
    123
    """


def fizz_buzz(n: int):
    """Adja vissza, hogy hányszor jelenik meg a 7-es számjegy n-nél kisebb egész számokban, amelyek oszthatók 11-gyel vagy 13-mal.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Azt adja meg, hogy hányszor jelenik meg a 7-es szám n-nél kisebb egész számokban, amelyek oszthatók 11-gyel vagy 13-mal.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """

def fizz_buzz(n: int):
    """Visszaadja annak a számnak az előfordulásait, amelyben a 7-es számjegy szerepel az n-nél kisebb számok között,
    amelyek oszthatók 11-tel vagy 13-mal.
    >>> fizz_buzz(50)
    0
    >>> fizz_buzz(78)
    2
    >>> fizz_buzz(79)
    3
    """


def sort_even(l: list):
    """Ez a függvény egy l listát kap bemenetként, és egy olyan l' listát ad vissza,
    amely azonos az l listával a páratlan indexeken, miközben az értékek a páros indexeken
    megegyeznek az l páros indexeinek értékeivel, de rendezve vannak.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Ez a függvény vesz egy l listát, és visszaad egy l' listát úgy, hogy
    l' azonos l-lel a páratlan indexekben, míg értékei a páros indexeknél egyenlőek
    az l páros indexeinek értékeihez, de rendezve.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """

def sort_even(l: list):
    """Ez a függvény egy l listát fogad, és egy olyan l listát ad vissza, ahol
    l' megegyezik l-lel páratlan indexek esetén, páros indexeknél pedig
    a páros indexek értékeivel egyezik meg, de rendezve.
    >>> sort_even([1, 2, 3])
    [1, 2, 3]
    >>> sort_even([5, 6, 3, 4])
    [3, 6, 5, 4]
    """


def encode_cyclic(s: str):
    """
    visszatér az adott karakterlánccal, amelyet háromkarakteres csoportok ciklikus eltolásával kódolt.
    """
    # bontsa fel a karakterláncot csoportokra. Mindegyik hossza 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # ciklikusan tolja el az egyes csoportok elemeit, kivéve, ha a csoport kevesebb elemből áll, mint 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    bemeneti karakterláncot vár, amelyet az encode_cyclic függvénnyel kódoltak. Visszatér a dekódolt karakterlánccal.
    """

def encode_cyclic(s: str):
    """
    kódolt karakterláncot ad vissza három karakterből álló csoportok ciklusával.
    """
    # split string to groups. Each of length 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cycle elements in each group. Unless group has fewer elements than 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic függvénnyel kódolt bemeneti karakterláncot veszi fel. Visszaadja a dekódolt karakterláncot.
    """

def encode_cyclic(s: str):
    """
    Kódolt karakterláncot ad vissza három karakterből álló ciklikus csoportok alapján.
    """
    # Karakterlánc felosztása csoportokra. Mindegyik hossza 3.
    groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
    # cikluselemek az egyes csoportokban. Kivéve, ha a csoport kevesebb elemet tartalmaz, mint 3.
    groups = [(group[1:] + group[0]) if len(group) == 3 else group for group in groups]
    return "".join(groups)

def decode_cyclic(s: str):
    """
    encode_cyclic függvénnyel kódolt bemeneti sztringként veszi fel. Dekódolt karakterláncot ad vissza.
    """


def prime_fib(n: int):
    """
    prime_fib visszaadja az n-edik számot, amely Fibonacci-szám és egyben prímszám is.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    A prime_fib azt az n-edik számot adja vissza, amely egy Fibonacci-szám, és amely prímszám is.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """

def prime_fib(n: int):
    """
    prime_fib n-edik számot ad vissza, amely egy Fibonacci-szám, és prím is.
    >>> prime_fib(1)
    2
    >>> prime_fib(2)
    3
    >>> prime_fib(3)
    5
    >>> prime_fib(4)
    13
    >>> prime_fib(5)
    89
    """


def triples_sum_to_zero(l: list):
    """
    A triples_sum_to_zero inputja egész számok listája.
    True értéket ad vissza, ha a listában van három olyan különböző elem,
    amelyek összege nulla, különben False értéket ad vissza.

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero egész számok listáját veszi bemenetként.
    Igaz értéket ad vissza, ha a listában három olyan különböző elem van, amely
    összeg nullára, egyébként pedig Hamis.

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

def triples_sum_to_zero(l: list):
    """
    triples_sum_to_zero egy egész számokat tartalmazó listát kap bemenetként.
    Igaz értéket ad vissza, ha a listában található három különböző elem összege nulla,
    és Hamis értéket, ha nem.

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


def car_race_collision(n: int):
    """
    Képzelj el egy utat, amely egy tökéletesen egyenes, végtelen hosszúságú vonal.
    n autó halad balról jobbra; eközben egy másik n autó halad jobbról balra.
    A két autósor kezdetben nagyon messze van egymástól. Minden autó ugyanazon a sebességgel halad.
    Két autó akkor ütközik, amikor egy balról jobbra haladó autó eltalál egy jobbról balra haladó autót.
    Azonban az autók végtelenül masszívak és erősek; ennek következtében tovább haladnak
    az eredeti irányukban, mintha nem is ütköztek volna.

    Ez a függvény kiadja az ilyen ütközések számát.
    """

def car_race_collision(n: int):
    """
    Képzeljen el egy utat, amely tökéletesen egyenes, végtelenül hosszú vonal.
    n autó halad balról jobbra;  Ezzel egyidejűleg egy másik N autókészlet
    jobbról balra haladnak.   A két autókészlet nagyon messze van
    egymást.  Minden autó azonos sebességgel mozog.  Azt mondják, hogy két autó ütközik
    Amikor egy balról jobbra haladó autó nekiütközik egy jobbról balra haladó autónak.
    Az autók azonban végtelenül erősek és erősek; Ennek eredményeként tovább mozognak
    a pályájukon, mintha nem ütköznének.

    Ez a funkció adja ki az ilyen ütközések számát.
    """

def car_race_collision(n: int):
    """
    Képzeljük el, hogy az út egy tökéletes egyenes, amely a végtelenbe nyúlik.
    Az n autók balról jobbra haladnak; egyidejűleg egy másik n autócsoport
    jobbról balra halad. Mindkét autócsoport kezdetben nagyon távol van egymástól.
    Minden autó ugyanazzal a sebességgel mozog. Amikor egy balról jobbra haladó autó
    találkozik egy jobbról balra haladó autóval, azt ütközésnek nevezzük.
    Azonban az autók rendkívül tartósak és erősek; ennek eredményeként folytatják
    az útjukat, mintha semmilyen ütközés nem történt volna.

    Ez a függvény visszaadja az ilyen ütközések számát.
    """


def incr_list(l: list):
    """Visszatérési lista 1-gyel megnövelt elemekkel.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Visszatérési lista 1-gyel növelt elemekkel.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """

def incr_list(l: list):
    """Add vissza a listát, amelynek elemei eggyel növelve vannak.
    >>> incr_list([1, 2, 3])
    [2, 3, 4]
    >>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
    [6, 4, 6, 3, 4, 4, 10, 1, 124]
    """


def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero egy egész számokat tartalmazó listát vesz bemenetként.
    Ha a listában létezik két különböző elem, amelyek összege 0, akkor True értéket ad vissza,
    egyéb esetben False értéket.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    A pairs_sum_to_zero egy egész számokat tartalmazó lista bemeneteként működik.
    True-t ad vissza, ha a listában két különböző elem van, amelyek összege nulla,
    és False-t ad vissza, ha nincs ilyen pár.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """

def pairs_sum_to_zero(l):
    """
    pairs_sum_to_zero egész számok listáját veszi bemenetként.
    Igaz értéket ad vissza, ha a listában két olyan különálló elem található, amely
    összeg nullára, egyébként pedig Hamis.
    >>> pairs_sum_to_zero([1, 3, 5, 0])
    False
    >>> pairs_sum_to_zero([1, 3, -2, 1])
    False
    >>> pairs_sum_to_zero([1, 2, 3, 7])
    False
    >>> pairs_sum_to_zero([2, 4, -5, 3, 5, 7])
    True
    >>> pairs_sum_to_zero([1])
    False
    """


def change_base(x: int, base: int):
    """Változtassa meg az x bemeneti szám alapját egy másik alapra.
    Adja vissza a konvertált szám sztring ábrázolását.
    Az alap kisebb, mint 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Módosítsa az x bemeneti szám numerikus alapját bázisra.
    karakterlánc-reprezentációt ad vissza az átalakítás után.
    az alapszámok 10-nél kisebbek.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """

def change_base(x: int, base: int):
    """Módosítsa az x bemeneti szám numerikus alapját alapra.
    karakterlánc-ábrázolás visszaadása az átalakítás után.
    Az alapszámok kisebbek, mint 10.
    >>> change_base(8, 3)
    '22'
    >>> change_base(8, 2)
    '1000'
    >>> change_base(7, 2)
    '111'
    """


def triangle_area(a, h):
    """Adott oldalhossz és magasság alapján visszaadja a háromszög területét.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Adott egy oldalhossz és magasság, számítsd ki a háromszög területét.
    >>> triangle_area(5, 3)
    7.5
    """

def triangle_area(a, h):
    """Adott egy háromszög oldalának hossza és magassága. Visszaadja a háromszög területét.
    >>> triangle_area(5, 3)
    7.5
    """


def fib4(n: int):
    """A Fib4 számsorozat egy olyan sorozat, amely hasonló a Fibonacci-sorozathoz, és az alábbiak szerint van definiálva:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Írjon egy függvényt, amely hatékonyan kiszámítja a fib4 számsorozat n-edik elemét. Ne használjon rekurziót.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    ""A Fib4 számsorozat a Fibbonacci-szekvenciához hasonló sorozat, amely a következőképpen van definiálva:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Kérjük, írjon egy függvényt a fib4 számsorozat n-edik elemének hatékony kiszámításához.  Ne használjon rekurziót.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """

def fib4(n: int):
    """A Fib4 számsorozat a Fibbonacci szekvenciához hasonló szekvencia, amelyet a következőképpen határozunk meg:
    fib4(0) -> 0
    fib4(1) -> 0
    fib4(2) -> 2
    fib4(3) -> 0
    fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
    Kérjük, írjon egy függvényt a fib4 számsorozat n-edik elemének hatékony kiszámításához.  Ne használjon rekurziót.
    >>> fib4(5)
    4
    >>> fib4(6)
    8
    >>> fib4(7)
    14
    """


def median(l: list):
    """Az l. lista elemeinek mediánját adja vissza.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Visszatér a lista l elemeinek mediánjával.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """

def median(l: list):
    """Visszaadja az l lista elemeinek mediánját.
    >>> median([3, 1, 2, 4, 5])
    3
    >>> median([-10, 4, 6, 1000, 10, 20])
    15.0
    """


def is_palindrome(text: str):
    """
    Ellenőrzi, hogy az adott karakterlánc palindrom-e
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """

def is_palindrome(text: str):
    """
    Ellenőrzi, hogy adott karakterlánc palindrom-e.
    >>> is_palindrome('')
    True
    >>> is_palindrome('aba')
    True
    >>> is_palindrome('aaaaa')
    True
    >>> is_palindrome('zbcd')
    False
    """


def modp(n: int, p: int):
    """A 2^n modulo p eredményét adja vissza (figyelj a számokra).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Adja vissza a 2^n modulo p értéket (legyen tisztában a számokkal).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """

def modp(n: int, p: int):
    """Visszatérés 2^n modulo p (ügyeljen a számokra).
    >>> modp(3, 5)
    3
    >>> modp(1101, 101)
    2
    >>> modp(0, 101)
    1
    >>> modp(3, 11)
    8
    >>> modp(100, 101)
    1
    """


def encode_shift(s: str):
    """
    Egy kódolt karakterláncot ad vissza, amelyben minden karakter az ábécében 5 karakterrel el van tolva.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    A bemenete az encode_shift függvénnyel kódolt karakterlánc. A kimenete a dekódolt karakterlánc.
    """

def encode_shift(s: str):
    """
    Kódolt karakterláncot ad vissza úgy, hogy az ábécé minden karakterét 5-tel eltolja.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    encode_shift függvénnyel kódolt bemeneti sztringként veszi fel. Dekódolt karakterláncot ad vissza.
    """

def encode_shift(s: str):
    """
    visszaadja a kódolt karakerláncot azáltal, hogy az ábécé minden karakterét 5-tel eltolja.
    """
    return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])

def decode_shift(s: str):
    """
    bemenetként egy olyan karakterláncot kap, amelyet az encode_shift függvénnyel kódoltak.
    Visszaadja a dekódolt karakterláncot.
    """


def remove_vowels(text):
    """
    remove_vowels egy olyan függvény, amely karakterláncot vesz fel, és magánhangzók nélküli karakterláncot ad vissza.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    A remove_vowels egy olyan függvény, amely karakterláncot vesz fel, és magánhangzók nélkül ad vissza stringet.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """

def remove_vowels(text):
    """
    A remove_vowels egy olyan függvény, amely egy karakterláncot fogad, és egy karakterláncot ad vissza magánhangzók nélkül.
    >>> remove_vowels('')
    ''
    >>> remove_vowels("abcdef\nghijklm")
    'bcdf\nghjklm'
    >>> remove_vowels('abcdef')
    'bcdf'
    >>> remove_vowels('aaaaa')
    ''
    >>> remove_vowels('aaBAA')
    'B'
    >>> remove_vowels('zbcd')
    'zbcd'
    """


def below_threshold(l: list, t: int):
    """Igaz értéket ad vissza, ha az l listában szereplő összes szám a t küszöbérték alatt van.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Igaz értéket ad vissza, ha az l listában lévő összes szám kisebb, mint a t küszöbérték.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """

def below_threshold(l: list, t: int):
    """Ha az l listában szereplő összes szám a t küszöbérték alatt van, akkor adjon vissza igazat.
    >>> below_threshold([1, 2, 4, 10], 100)
    True
    >>> below_threshold([1, 20, 4, 10], 5)
    False
    """


def add(x: int, y: int):
    """Összead két számot, x-et és y-t.
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """

def add(x: int, y: int):
    """Adjon hozzá két x és y számot
    >>> add(2, 3)
    5
    >>> add (5, 7)
    12
    """

"""
k
def add(x: int, y: int):
    """Adjon össze két számot, x és y
    >>> add(2, 3)
    5
    >>> add(5, 7)
    12
    """


def same_chars(s0: str, s1: str):
    """
    Ellenőrizze, hogy két szóban azonos karakterek vannak-e.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """

def same_chars(s0: str, s1: str):
    """
    Ellenőrizze, hogy két szó azonos karakterekkel rendelkezik-e.
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
    True
    >>> same_chars('abcd', 'dddddddabc')
    True
    >>> same_chars('dddddddabc', 'abcd')
    True
    >>> same_chars('eabcd', 'dddddddabc')
    False
    >>> same_chars('abcd', 'dddddddabce')
    False
    >>> same_chars('eabcdzzzz', 'dddzzzzzzzddddabc')
    False
    """


def fib(n: int):
    """Visszaadja az n-edik Fibonacci-számot.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """

def fib(n: int):
    """Adja vissza az n-edik Fibonacci-számot.
    >>> fib(10)
    55
    >>> fib(1)
    1
    >>> fib(8)
    21
    """


def correct_bracketing(brackets: str):
    """ A brackets egy "<" és ">" karaktereket tartalmazó karakterlánc.
    Igazat adj vissza, ha minden nyitó zárójelnek megvan a záró párja.

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

def correct_bracketing(brackets: str):
    A """ zárójelek a "<" és a ">" karakterláncai.
    return True (Igaz), ha minden nyitó zárójelnek van megfelelő záró zárójele.

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

def correct_bracketing(brackets: str):
    """ A zárójel egy "<" és "">" karakterlánc.
    return True, ha minden nyitó zárójelhez tartozik egy megfelelő záró zárójel.

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


def monotonic(l: list):
    """Adjon vissza True értéket, ha a lista elemei monoton növekednek vagy csökkennek.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    ""Visszaadja True-t, a listaelek monoton növekednek vagy csökkennek.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """

def monotonic(l: list):
    """True értéket adjon vissza, ha a lista elemei monoton növekvőek vagy csökkenőek.
    >>> monotonic([1, 2, 4, 20])
    True
    >>> monotonic([1, 20, 4, 10])
    False
    >>> monotonic([4, 1, 0, -10])
    True
    """


def common(l1: list, l2: list):
    """Adja vissza két lista egyedi, rendezett közös elemeit.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Két lista rendezett egyedi közös elemeinek visszaadása.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """

def common(l1: list, l2: list):
    """Rendezett egyedi közös elemeket ad vissza két listához.
    >>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
    [1, 5, 653]
    >>> common([5, 3, 2, 8], [3, 2])
    [2, 3]

    """


def largest_prime_factor(n: int):
    """Adja vissza n legnagyobb prímtényezőjét. Tegyük fel, hogy n > 1, és nem prím.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """

def largest_prime_factor(n: int):
    """Add vissza n legnagyobb prímtényezőjét. Tegyük fel, hogy n > 1 és nem prímszám.
    >>> largest_prime_factor(13195)
    29
    >>> largest_prime_factor(2048)
    2
    """


def sum_to_n(n: int):
    """sum_to_n egy olyan függvény, amely 1 és n közötti számokat összegez.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """A sum_to_n egy olyan függvény, amely összeadja a számokat 1-től n-ig.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """

def sum_to_n(n: int):
    """A sum_to_n egy olyan függvény, amely 1-től n-ig összegzi a számokat.
    >>> sum_to_n(30)
    465
    >>> sum_to_n(100)
    5050
    >>> sum_to_n(5)
    15
    >>> sum_to_n(10)
    55
    >>> sum_to_n(1)
    1
    """


def correct_bracketing(brackets: str):
    """A zárójelek egy sorozata, amely csak "(" és ")" karaktereket tartalmaz.
    Visszaadja True értéket, ha minden nyitó zárójelhez tartozik egy záró zárójel.

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

def correct_bracketing(brackets: str):
    """ A zárójel egy "(" és ")" karakterlánc.
    return True, ha minden nyitó zárójelhez tartozik egy megfelelő záró zárójel.

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

def correct_bracketing(brackets: str):
    A """ szögletes zárójelek a "(" és ")" karakterláncai.
    return True (Igaz), ha minden nyitó zárójelnek van megfelelő záró zárójele.

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


def derivative(xs: list):
    """ xs egy polinom együtthatóit jelöli.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Adja vissza ennek a polinomnak a deriváltját ugyanabban a formában.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """

def derivative(xs: list):
    """ xs egy polinom együtthatóit jelenti.
    xs[0] + xs[1] * x + xs[2] * x^2 + ....
     Ennek a polinomnak a deriváltja ugyanabban az alakban.
    >>> derivative([3, 1, 2, 4, 5])
    [1, 4, 12, 20]
    >>> derivative([1, 2, 3])
    [2, 6]
    """


def fibfib(n: int):
    """A FibFib számsorozat egy olyan sorozat, amely hasonló a Fibonacci-sorozathoz, és az alábbiak szerint van definiálva:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Írjon egy függvényt, amely hatékonyan kiszámítja a fibfib számsorozat n-edik elemét.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    """A FibFib számszekvencia a Fibbonacci szekvenciához hasonló szekvencia, amelyet a következőképpen határozunk meg:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Please write a function to efficiently compute the n-th element of the fibfib number sequence.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """

def fibfib(n: int):
    ""A FibFib számsorozat a Fibbonacci-szekvenciához hasonló sorozat, amely a következőképpen van definiálva:
    fibfib(0) == 0
    fibfib(1) == 0
    fibfib(2) == 1
    fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
    Kérjük, írjon egy függvényt a fibfib számsorozat n-edik elemének hatékony kiszámításához.
    >>> fibfib(1)
    0
    >>> fibfib(5)
    4
    >>> fibfib(8)
    24
    """


FIX = """
Add more test cases.
"""

def vowels_count(s):
    """Írjon egy vowels_count függvényt, amely egy karakterláncot képvisel
    egy szót bemenetként, és visszaadja a karakterlánc magánhangzóinak számát.
    A magánhangzók ebben az esetben az „a”, „e”, „i”, „o”, „u”. Itt az „y” is a
    magánhangzó, de csak akkor, ha az adott szó végén van.

    Példa:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Add more test cases.
"""

def vowels_count(s):
    """Írjon egy vowels_count függvényt, amely egy karakterláncot reprezentál
    egy szót bemenetként, és visszaadja a karakterlánc magánhangzóinak számát.
    A magánhangzók ebben az esetben az 'a', 'e', 'i', 'o', 'u'. Itt az 'y' is a
    magánhangzó, de csak akkor, ha az adott szó végén van.

    Példa:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """

FIX = """
Adjon hozzá további teszteseteket.
"""

def vowels_count(k):
    """Írjon egy függvény vowels_count, amely egy karakterláncot képvisel
    egy szót bemenetként, és visszaadja a karakterláncban lévő magánhangzók számát.
    A magánhangzók ebben az esetben "a", "e", "i", "o", "u". Itt az "y" is egy
    magánhangzó, de csak akkor, ha az adott szó végén van.

    Példa:
    >>> vowels_count("abcde")
    2
    >>> vowels_count("ACEDY")
    3
    """


def circular_shift(x, shift):
    """Körkörösen told el az x egész szám számjegyeit. A számjegyeket jobbra told el a shift paraméter által megadott számmal,
    és az eredményt karakterlánc formájában add vissza.
    Ha a shift nagyobb a számjegyek számánál, a számjegyeket visszafele add vissza.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Körkörösen tolja el az x egész szám számjegyeit, tolja el a számjegyeket jobbra shifttel
    , és az eredményt karakterláncként adja vissza.
    Ha eltolja > számjegyek számát, a visszatérő számjegyek megfordulnak.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """

def circular_shift(x, shift):
    """Az x egész számjegyeinek körkörös eltolása, a számjegyek eltolása jobbra
    és az eredményt karakterláncként adja vissza.
    Ha eltolás > számjegyek száma, a számjegyek megfordítva térnek vissza.
    >>> circular_shift(12, 1)
    "21"
    >>> circular_shift(12, 2)
    "12"
    """


def digitSum(s):
    """Feladat
    Írj egy függvényt, amely bemenetként egy karakterláncot vesz, és csak a nagybetűk ASCII kódjainak összegét adja vissza.

    Példa:
    digitSum("") => 0
    digitSum("abAB") => 131
    digitSum("abcCd") => 67
    digitSum("helloE") => 69
    digitSum("woArBld") => 131
    digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Feladat
    Írjon egy függvényt, amely bemenetként karakterláncot vesz fel, és csak a felső karakterek összegét adja vissza.
    ASCII-kódok.

    Példák:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """

def digitSum(s):
    """Feladat
    Írjon egy függvényt, amely egy karakterláncot vesz be, és csak a felső karakterek összegét adja vissza.
    ASCII kódok.

    Példák:
        digitSum("") => 0
        digitSum("abAB") => 131
        digitSum("abcCd") => 67
        digitSum("helloE") => 69
        digitSum("woArBld") => 131
        digitSum("aAaaaXa") => 153
    """


def fruit_distribution(s,n):
    """
    Ebben a feladatban kap egy karakterláncot, amely számos almát és narancsot képvisel
    amelyeket egy kosár gyümölcsben osztanak szét, amelyet ez a kosár tartalmaz
    alma, narancs és mangó gyümölcs. A karakterlánc alapján, amely a
    a narancs és az alma, valamint egy egész szám, amely a gyümölcsök teljes számát jelöli
    A kosárban adja vissza a kosárban lévő mangó gyümölcsök számát.
    vizsgáztatás esetén:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """

def fruit_distribution(s,n):
    """
    Ebben a feladatban kapsz egy karakterláncot, amely számos almát és narancsot jelöl
    amelyek egy gyümölcskosárban vannak elosztva, amelyeket ez a kosár tartalmaz
    alma, narancs és mangó gyümölcs. Adott a karakterlánc, amely a teljes számát jelenti
    a narancs és az alma, valamint egy egész szám, amely a gyümölcsök teljes számát jelenti
    a kosárban adja vissza a kosárban lévő mangó gyümölcsök számát.
    például:
    fruit_distribution("5 apples and 6 oranges", 19) ->19 - 5 - 6 = 8
    fruit_distribution("0 apples and 1 oranges",3) -> 3 - 0 - 1 = 2
    fruit_distribution("2 apples and 3 oranges", 100) -> 100 - 2 - 3 = 95
    fruit_distribution("100 apples and 1 oranges",120) -> 120 - 100 - 1 = 19
    """


def pluck(arr):
    """
    "Adott egy tömb, amely egy fa ágát reprezentálja, amely nem negatív egész csomópontokkal rendelkezik
    az Ön feladata az egyik csomópont eltávolítása és visszaadása.
    A kitépett csomópontnak a legkisebb páros értékű csomópontnak kell lennie.
    Ha több, azonos legkisebb páros értékű csomópont található, akkor a legkisebb indexű csomópontot adja vissza.

    A kiszemelt csomópontot egy listában kell visszaadni: [ legkisebb_érték, indexe ],
    Ha nincsenek páros értékek, vagy az adott tömb üres, adja vissza a []-t.

    1. példa:
        Input: [4,2,3]
        Output: [2, 1]
        Magyarázat: a 2-nek a legkisebb páros értéke, a 2-nek pedig a legkisebb az indexe.

    2. példa:
        Input: [1,2,3]
        Output: [2, 1]
        Magyarázat: a 2-nek a legkisebb páros értéke, a 2-nek pedig a legkisebb az indexe.

    3. példa:
        Input: []
        Output: []

    4. példa:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        Magyarázat: 0 a legkisebb érték, de két nulla van,
                     így az első nullát választjuk, amelyiknek a legkisebb az indexe.

    Korlátozások:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Adott egy tömb, amely egy fa ágát képviseli, amely nem negatív egész csomópontokkal rendelkezik
    Az Ön feladata, hogy kivágja az egyik csomópontot, és visszaadja.
    A kivágott csomópontnak a legkisebb páros értékű csomópontnak kell lennie.
    Ha több csomópont található ugyanazzal a legkisebb páros értékkel, adja vissza a legkisebb indexszel rendelkező csomópontot.

    A kivágott csomópontot vissza kell adni egy listában, [ smalest_value, annak indexe ],
    Ha nincsenek páros értékek, vagy az adott tömb üres, adja vissza a [] értéket.

    1. példa:
        Bemenet: [4,2,3]
        Kimenet: [2, 1]
        Magyarázat: A 2-nek van a legkisebb páros értéke, és a 2-nek a legkisebb az indexe.

    2. példa:
        Bemenet: [1,2,3]
        Kimenet: [2, 1]
        Magyarázat: A 2-nek van a legkisebb páros értéke, és a 2-nek a legkisebb az indexe.

    3. példa:
        Bemenet: []
        Kimenet: []

    4. példa:
        Bemenet: [5, 0, 3, 0, 4, 2]
        Kimenet: [0, 1]
        Magyarázat: 0 a legkisebb érték, de két nulla van,
                     Tehát az első nullát választjuk, amelynek a legkisebb indexe van.

    Korlátok:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """

def pluck(arr):
    """
    "Adott egy tömb, amely egy fa ágát reprezentálja, amely nem negatív egész csomópontokkal rendelkezik
    az Ön feladata az egyik csomópont eltávolítása és visszaadása.
    A kitépett csomópontnak a legkisebb páros értékű csomópontnak kell lennie.
    Ha több, azonos legkisebb páros értékű csomópont található, akkor a legkisebb indexű csomópontot adja vissza.

    A kiszemelt csomópontot egy listában kell visszaadni, [ legkisebb_érték, indexe ],
    Ha nincsenek páros értékek, vagy az adott tömb üres, adja vissza a []-t.

    1. példa:
        Input: [4,2,3]
        Output: [2, 1]
        Magyarázat: a 2-nek a legkisebb páros értéke, a 2-nek pedig a legkisebb az indexe.

    2. példa:
        Input: [1,2,3]
        Output: [2, 1]
        Magyarázat: a 2-nek a legkisebb páros értéke, a 2-nek pedig a legkisebb az indexe.

    3. példa:
         Input: []
        Output: []

    4. példa:
        Input: [5, 0, 3, 0, 4, 2]
        Output: [0, 1]
        Magyarázat: 0 a legkisebb érték, de két nulla van,
                     így az első nullát választjuk, amelyiknek a legkisebb az indexe.

    Korlátozások:
        * 1 <= nodes.length <= 10000
        * 0 <= node.value
    """


def search(lst):
    '''
    Kap egy nem üres listát a pozitív egész számokról. A legnagyobb egész számot adja eredményül, amely nagyobb, mint
    nulla, és frekvenciája nagyobb vagy egyenlő, mint maga az egész szám értéke.
    Egy egész szám gyakorisága az a szám, ahányszor megjelenik a listában.
    Ha nincs ilyen érték, adja vissza a -1 értéket.
    Példák:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Kapsz egy nem üres listát a pozitív egész számokról. A legnagyobb egész számot adja vissza, amely nagyobb, mint
    nulla, és gyakorisága nagyobb vagy egyenlő, mint magának az egész számnak az értéke.
    Egy egész szám gyakorisága azt jelenti, hogy hányszor jelenik meg a listában.
    Ha nincs ilyen érték, adjon vissza -1-et.
    Példák:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''

def search(lst):
    '''
    Adott egy nem üres lista pozitív egész számokkal. Adja vissza a legnagyobb egész számot, amely nagyobb mint 0 és a gyakorisága nagyobb vagy egyenlő a saját értékénél.
    Egy egész szám gyakorisága a lista előfordulásainak száma.
    Ha ilyen érték nem létezik, -1-et ad vissza.
    Példa:
        search([4, 1, 2, 2, 3, 1]) == 2
        search([1, 2, 2, 3, 3, 3, 4, 4, 4]) == 3
        search([5, 5, 4, 4, 4]) == -1
    '''


def strange_sort_list(lst):
    '''
    Adott egész számok listája, furcsa sorrendben adja vissza a listát.
    Furcsa rendezés, amikor a minimális értékkel kezded,
    majd a maradék egész számok maximuma, majd a minimum és így tovább.

    Példák:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Adott egy egész számok listája, adja vissza a listát strange sorrendben.
    A strange sorrend a legkisebb értékkel kezdődik, majd a maradék egész számok közül a legnagyobb érték következik,
    aztán a legkisebb érték, és így tovább.

    Példa:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''

def strange_sort_list(lst):
    '''
    Megadott egész számok listája, visszatérési lista furcsa sorrendben.
    Furcsa rendezés, amikor a minimális értékkel kezdődik,
    Ezután a fennmaradó egész számok maximuma, majd a minimum és így tovább.

    Példák:
    strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
    strange_sort_list([5, 5, 5, 5]) == [5, 5, 5, 5]
    strange_sort_list([]) == []
    '''


def triangle_area(a, b, c):
    '''
    Adott egy háromszög három oldalának a hossza. Add vissza a háromszög területét
    két tizedesjegyre kerekítve, ha a három oldal érvényes háromszöget alkot.
    Egyébként -1 értéket adja vissza.
    Három oldal akkor alkot érvényes háromszöget, ha bármely két oldal összege
    nagyobb, mint a harmadik oldal.
    Példa:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Adott a háromszög három oldalának hossza. Adja vissza a
    háromszög területét 2 tizedesjegyre kerekítve, ha a három oldal érvényes háromszöget alkot.
    Ellenkező esetben visszatérés -1
    Három oldal érvényes háromszöget alkot, ha bármely két oldal összege nagyobb
    mint a harmadik oldal.
    Példa:
    triangle_area(3, 4, 5) == 6,00
    triangle_area(1, 2, 10) == -1
    '''

def triangle_area(a, b, c):
    '''
    Adott egy háromszög három oldalának hossza. A terület visszaadása
    a háromszög 2 tizedesjegyre kerekítve, ha a három oldal érvényes háromszöget alkot.
    Ellenkező esetben -1
    Három oldal akkor alkot érvényes háromszöget, ha bármely két oldal összege nagyobb
    mint a harmadik oldal.
    Példa:
    triangle_area(3, 4, 5) == 6.00
    triangle_area(1, 2, 10) == -1
    '''


def will_it_fly(q,w):
    '''
    Írjon egy függvényt, amely igazat ad vissza, ha a q objektum repül, és hamis értéket ad vissza.
    A q objektum akkor repül, ha kiegyensúlyozott (ez egy palindromlista), és elemeinek összege kisebb vagy egyenlő, mint a maximális lehetséges w súly.

    Példa:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 kisebb, mint a maximálisan lehetséges súly, de kiegyensúlyozatlan.

    will_it_fly([3, 2, 3], 1) ➞ False
    # kiegyensúlyozott, de a 3+2+3 több, mint a maximálisan lehetséges súly.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 kisebb, mint a megengedett maximális súly, és kiegyensúlyozott.

    will_it_fly([3], 5) ➞ True
    # 3 kisebb, mint a megengedett maximális súly, és kiegyensúlyozott.
    '''

def will_it_fly(q,w):
    '''
    Írjon egy függvényt, amely Igaz értéket ad vissza, ha a q objektum repülni fog, egyébként pedig Hamis.
    A q objektum akkor repül, ha kiegyensúlyozott (palindrom lista), és elemeinek összege kisebb vagy egyenlő a w maximális lehetséges tömeggel.

    Példa:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 kisebb, mint a maximális lehetséges súly, de kiegyensúlyozatlan.

    will_it_fly([3, 2, 3], 1) ➞ False
    # kiegyensúlyozott, de a 3+2+3 több, mint a maximális lehetséges súly.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3 + 2 + 3 kevesebb, mint a maximális lehetséges súly, és kiegyensúlyozott.

    will_it_fly([3], 5) ➞ True
    # 3 kisebb, mint a maximális lehetséges súly, és kiegyensúlyozott.
    '''

def will_it_fly(q,w):
    '''
    Írj egy függvényt, amely True értéket ad vissza, ha az objektum q repülni fog, és False-t egyébként.
    Az objektum q repülni fog, ha kiegyensúlyozott (palindromikus lista), és az elemeinek összege kisebb vagy egyenlő, mint a maximális engedélyezett súly w.

    Példa:
    will_it_fly([1, 2], 5) ➞ False
    # 1+2 kisebb, mint a maximális engedélyezett súly, de nem kiegyensúlyozott.

    will_it_fly([3, 2, 3], 1) ➞ False
    # kiegyensúlyozott, de 3+2+3 több, mint a maximális engedélyezett súly.

    will_it_fly([3, 2, 3], 9) ➞ True
    # 3+2+3 kisebb, mint a maximális engedélyezett súly, és kiegyensúlyozott.

    will_it_fly([3], 5) ➞ True
    # 3 kisebb, mint a maximális engedélyezett súly, és kiegyensúlyozott.
    '''


def smallest_change(arr):
    """
    Adott egy egész számokat tartalmazó arr tömb. Állapítsd meg azt a minimális elemszámot,
    amelyet meg kell változtatni ahhoz, hogy a tömb palindróma legyen. A palindróma tömb olyan
    tömb, amely elölről hátra és hátulról előre olvasva is ugyanaz. Egy elemet egy változtatással
    egy másik elemre lehet cserélni.

    Például:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Egész számok tömbarr esetén keresse meg az elemek minimális számát, amelyek
    meg kell változtatni, hogy a tömb palindromikus legyen. A palindrom tömb olyan tömb, amely
    ugyanúgy olvasható előre és visszafelé. Egy módosítással módosíthatja az egyik elemet bármely másik elemre.

    Például:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """

def smallest_change(arr):
    """
    Adott egy arr egész számokból álló tömb, keresse meg az elemek minimális számát
    meg kell változtatni, hogy a tömb palindromikus legyen. A palindrom tömb olyan tömb, amely
    ugyanazt olvassa vissza és előre. Egy változtatás során az egyik elemet bármely másik elemre módosíthatja.

    Például:
    smallest_change([1,2,3,5,4,7,9,6]) == 4
    smallest_change([1, 2, 3, 4, 3, 2, 2]) == 1
    smallest_change([1, 2, 3, 2, 1]) == 0
    """


def total_match(lst1, lst2):
    '''
    Írjon egy olyan függvényt, amely két karakterláncokat tartalmazó listát fogad el,
    és visszaadja azt a listát, amelyben az összes karakterlánc összesített karaktereinek száma kisebb, mint a másik listában.

    Ha a két listában az összes karakter száma megegyezik, adja vissza az első listát.

    Példák
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Írjon egy függvényt, amely elfogad két karakterlánclistát, és visszaadja azt a listát, amelyiknek van
    a lista összes karakterláncában lévő karakterek teljes száma kevesebb, mint a másik listában.

    ha a két listában ugyanannyi karakter van, akkor az első listát adja vissza.

    Példák
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''

def total_match(lst1, lst2):
    '''
    Írjon egy függvényt, amely két karakterlánclistát fogad el, és visszaadja azt a listát, amely
    A karakterek teljes száma a lista összes karakterláncában kisebb, mint a másik listában.

    Ha a két lista azonos számú karaktert tartalmaz, adja vissza az első listát.

    Példák
    total_match([], []) ➞ []
    total_match(['hi', 'admin'], ['hI', 'Hi']) ➞ ['hI', 'Hi']
    total_match(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) ➞ ['hi', 'admin']
    total_match(['hi', 'admin'], ['hI', 'hi', 'hi']) ➞ ['hI', 'hi', 'hi']
    total_match(['4'], ['1', '2', '3', '4', '5']) ➞ ['4']
    '''


def is_multiply_prime(a):
    """Függvény, amely True értéket ad vissza, ha az adott szám 3 prímszám szorzata.
    Egyébként False értéket ad vissza.
    Tudjuk, hogy (a) kisebb, mint 100.
    Példa:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Írjon egy függvényt, amely igazat ad vissza, ha a megadott szám 3 prímszám szorzata!
    és egyébként hamis.
    Tudva, hogy (a) kisebb, mint 100.
    Példa:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """

def is_multiply_prime(a):
    """Írjon egy függvényt, amely igaz értéket ad vissza, ha az adott szám 3 prímszám szorzata
    és hamis egyébként.
    Tudva, hogy (a) kevesebb, mint 100.
    Példa:
    is_multiply_prime(30) == True
    30 = 2 * 3 * 5
    """


def is_simple_power(x, n):
    """A feladat az, hogy írjon egy olyan függvényt, amely igazat ad vissza,
    ha az x szám egyszerű hatványa az n számnak, és hamisat más esetekben.
    x egyszerű hatványa az n-nek, ha n**int=x
    Példák:
    is_simple_power(1, 4) => igaz
    is_simple_power(2, 2) => igaz
    is_simple_power(8, 2) => igaz
    is_simple_power(3, 2) => hamis
    is_simple_power(3, 1) => hamis
    is_simple_power(5, 3) => hamis
    """

def is_simple_power(x, n):
    """Az Ön feladata, hogy írjon egy függvényt, amely igazat ad vissza, ha egy x szám egyszerű
    n hatványa és hamis más esetekben.
    x n egyszerű hatványa, ha n**int=x
    Például:
    is_simple_power(1, 4) => true
    is_simple_power(2, 2) => true
    is_simple_power(8, 2) => true
    is_simple_power(3, 2) => false
    is_simple_power(3, 1) => false
    is_simple_power(5, 3) => false
    """


def iscube(a):
    '''
    Írjon egy olyan függvényt, amely egy egész számot, a-t vesz fel, és visszaadja a True értéket,
    ha ez az egész szám egy másik egész szám köbének felel meg.
    Megjegyzés: feltételezheti, hogy a bemenet mindig érvényes.
    Példák:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def ISCUBE(A):
    '''
    Írjon egy függvényt, amely egy a egész számot vesz fel, és Igaz értéket ad vissza
    ha ez a beingeger valamilyen egész szám kockája.
    Megjegyzés: feltételezheti, hogy a bemenet mindig érvényes.
    Példák:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''

def iscube(a):
    '''
    Írjon egy függvényt, amely egy a egész számot vesz fel, és igazat ad vissza
    ha ez az ingeger valamilyen egész számból álló kocka.
    Megjegyzés: feltételezheti, hogy a bevitel mindig érvényes.
    Példák:
    iscube(1) ==> True
    iscube(2) ==> False
    iscube(-1) ==> True
    iscube(64) ==> True
    iscube(0) ==> True
    iscube(180) ==> False
    '''


def hex_key(num):
    """ Feladata egy olyan függvény írása, amely egy hexadecimális számot kap meg
    karakterláncként, és megszámolja azon hexadecimális számjegyek számát,
    amelyek prímek (a prímszám olyan 1-nél nagyobb természetes szám, amely
    nem hozható létre két kisebb természetes szám szorzataként).
    A hexadecimális számjegyek: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    A prímszámok: 2, 3, 5, 7, 11, 13, 17,...
    Tehát meg kell határozni a következő számjegyek számát: 2, 3, 5, 7,
    B (=decimális 11), D (=decimális 13).
    Megjegyzés: feltételezheti, hogy a bemenet mindig helyes vagy üres karakterlánc,
    és az A, B, C, D, E, F szimbólumok mindig nagybetűsek.
    Examples:
    For num = "AB" the output should be 1.
    For num = "1077E" the output should be 2.
    For num = "ABED1A33" the output should be 4.
    For num = "123456789ABCDEF0" the output should be 6.
    For num = "2020" the output should be 2.
    """

def hex_key(num):
    """Azt a feladatot kapta, hogy írjon egy függvényt, amely fogadja
    hexadecimális szám karakterláncként, és megszámolja a hexadecimális
    olyan számjegyek, amelyek prímek (prímszám vagy prímszám természetes szám
    nagyobb, mint 1, ami nem két kisebb természetes szám szorzata).
    A hexadecimális számjegyek: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    A prímszámok: 2, 3, 5, 7, 11, 13, 17,...
    Tehát meg kell határoznia a következő számjegyek számát: 2, 3, 5, 7,
    B (=decimális 11), D (=decimális 13).
    Megjegyzés: feltételezheti, hogy a bemenet mindig helyes vagy üres karakterlánc,
    és az A,B,C,D,E,F szimbólumok mindig nagybetűk.
    Példák:
    num = "AB" esetén a kimenetnek 1-nek kell lennie.
    Num = "1077E" esetén a kimenetnek 2-nek kell lennie.
    num = "ABED1A33" esetén a kimenetnek 4-nek kell lennie.
    Num = "123456789ABCDEF0" esetén a kimenetnek 6-nak kell lennie.
    Num = "2020" esetén a kimenetnek 2-nek kell lennie.
    """

def hex_key(num):
    """Azt a feladatot kapta, hogy írjon egy függvényt, amely fogad
    egy hexadecimális számot karakterláncként, és megszámolja a hexadecimális számok számát
    olyan számjegyek, amelyek prímszámok (prímszám vagy prím, természetes szám
    1-nél nagyobb, ami nem két kisebb természetes szám szorzata).
    A hexadecimális számjegyek 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F.
    A prímszámok 2, 3, 5, 7, 11, 13, 17,...
    Tehát meg kell határoznia a következő számjegyek számát: 2, 3, 5, 7,
    B (=tizedes 11), D (=tizedes 13).
    Megjegyzés: feltételezheti, hogy a bevitel mindig helyes vagy üres karakterlánc,
    és az A,B,C,D,E,F szimbólumok mindig nagybetűk.
    Példák:
    For num = "AB" the output should be 1.
    For num = "1077E" the output should be 2.
    For num = "ABED1A33" the output should be 4.
    For num = "123456789ABCDEF0" the output should be 6.
    For num = "2020" the output should be 2.
    """


def decimal_to_binary(decimal):
    """Kapsz egy számot decimális formában, és a feladatod az, hogy
    bináris formátumúvá alakítsd. A függvény egy karakterláncot adjon vissza, amelyben minden karakter egy bináris szám.
    A karakterláncban minden karakter '0' vagy '1'.

    A karakterlánc elején és végén legyen egy plusz karakterpár: 'db'.
    A plusz karakterek feladata, hogy segítsenek a formátumban.

    Példák:
    decimal_to_binary(15)   # a visszaadott karakterlánc "db1111db"
    decimal_to_binary(32)   # a visszaadott karakterlánc "db100000db"
    """

def decimal_to_binary(decimal):
    """Kapsz egy számot decimális formában, és az a feladatod, hogy átalakítsd
    bináris formátumban. A függvénynek egy sztringet kell visszaadnia, ahol minden karakter egy bináris karaktert képvisel
    szám. A karakterlánc minden karaktere "0" vagy "1" lesz.

    A karakterlánc elején és végén lesz egy további pár "db" karakter.
    Az extra karakterek segítenek a formátumban.

    Példák:
    decimal_to_binary(15) # eredménye "db1111db"
    decimal_to_binary(32) # eredménye "db100000db"
    """

def decimal_to_binary(decimal):
    """Kapsz egy számot decimális formában, és az a feladatod, hogy ezt konvertáld
    bináris formátum. A függvénynek egy karakterláncot kell visszaadnia, ahol minden karakter egy binárist jelent
    szám. A karakterlánc minden karaktere „0” vagy „1” lesz.

    A karakterlánc elején és végén még egy pár „db” karakter lesz.
    Az extra karakterek azért vannak, hogy segítsenek a formátumban.

    Példák:
    decimal_to_binary(15)   # returns "db1111db"
    decimal_to_binary(32)   # returns "db100000db"
    """


def is_happy(s):
    """Egy karakterláncot kapunk s néven.
    A feladat annak ellenőrzése, hogy a karakterlánc boldog-e vagy sem.
    Egy karakterlánc boldog, ha hossza legalább 3, és minden 3 egymást követő betű különböző.
    Például:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Kapsz egy s karakterláncot.
    Az Ön feladata, hogy ellenőrizze, hogy a karakterlánc boldog-e vagy sem.
    Egy karakterlánc akkor boldog, ha a hossza legalább 3, és minden 3 egymást követő betű különbözik
    Például:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """

def is_happy(s):
    """Kapsz egy s karakterláncot.
    Az Ön feladata annak ellenőrzése, hogy a karakterlánc boldog-e vagy sem.
    Egy karakterlánc akkor boldog, ha a hossza legalább 3, és minden 3 egymást követő betű különbözik
    Például:
    is_happy(a) => False
    is_happy(aa) => False
    is_happy(abcd) => True
    is_happy(aabb) => False
    is_happy(adb) => True
    is_happy(xyy) => False
    """


def numerical_letter_grade(grades):
    """A szemeszter utolsó hete van, és a tanárnak értékelnie kell a diákokat.
    A tanár saját algoritmust készít az értékeléshez.
    A probléma az, hogy elvesztette a kódot, amit az értékeléshez használt.
    Adott neked egy listát néhány diák GPA-jéről, és írnod kell
    egy függvényt, amely vissza tudja adni a jegyek listáját a következő táblázat alapján:
    GPA | Jegy
    4.0 A+
    > 3.7 A
    > 3.3 A-
    > 3.0 B+
    > 2.7 B
    > 2.3 B-
    > 2.0 C+
    > 1.7 C
    > 1.3 C-
    > 1.0 D+
    > 0.7 D
    > 0.0 D-
    0.0 E

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

def numerical_letter_grade(grades):
    """A félév utolsó hete van, és a tanárnak kell osztályoznia
    diákoknak. A tanár saját algoritmust készített az osztályozáshoz.
    Az egyetlen probléma az, hogy elvesztette az osztályozáshoz használt kódot.
    Adott neked egy listát néhány diák GPA-járól, és neked írnod kell
    egy függvény, amely a következő táblázat segítségével képes kiadni a betűosztályzatok listáját:
             GPA |    Betű fokozat
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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

def numerical_letter_grade(grades):
    """Ez a félév utolsó hete, és a tanárnak meg kell adnia az osztályzatokat
    a diákoknak. A tanár saját algoritmust készített az osztályozáshoz.
    Az egyetlen probléma az, hogy elvesztette az osztályozáshoz használt kódot.
    Néhány hallgató számára megadta a GPA-k listáját, és írnia kell
    Egy függvény, amely az alábbi táblázat segítségével képes kiadni a betűosztályok listáját:
             GPA |    Betű fokozat
              4.0                A+
            > 3.7                A
            > 3.3                A-
            > 3.0                B+
            > 2.7                B
            > 2.3                B-
            > 2.0                C+
            > 1.7                C
            > 1.3                C-
            > 1.0                D+
            > 0.7                D
            > 0.0                D-
              0.0                E

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


"""Írjon egy függvényt, amely vesz egy karakterláncot, és True értéket ad vissza, ha a karakterlánc hossza prímszám,
és False értéket, ha nem az.
Példa
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""

def prime_length(string):
    """Írjon egy függvényt, amely egy karakterláncot vesz fel, és igazat ad vissza, ha a karakterlánc
    A hossza prímszám, vagy hamis, ellenkező esetben
    Példák
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """

def prime_length(string):
    """Írjon egy függvényt, amely egy karakterláncot vesz fel, és Igaz értéket ad vissza, ha a karakterlánc
    A length prímszám, egyébként hamis
    Példák
    prime_length('Hello') == True
    prime_length('abcdcba') == True
    prime_length('kittens') == True
    prime_length('orange') == False
    """


def starts_one_ends(n):
    """
    Adott egy pozitív egész szám n. Azoknak az n számjegyből álló
    pozitív egész számoknak a számát add vissza,
    amelyek az 1-es számjeggyel kezdődnek vagy végződnek.
    """

def starts_one_ends(n):
    """
    Ha adott egy pozitív egész szám n, adja vissza azon pozitív egész számok számát, amelyek n számjegyből állnak, és 1-es számjeggyel kezdődnek vagy végződnek.
    """

def starts_one_ends(n):
    """
    Adott egy pozitív n egész szám, adja vissza az n számjegyű számok számát
    1-gyel kezdődő vagy végződő pozitív egész számok.
    """


def solve(N):
    """Ha adott egy pozitív egész szám N, adja vissza a számjegyei összegét a kettes számrendszerben.

    Példa
    Ha N = 1000, a számjegyek összege 1, és a kimenetnek "1"-nek kell lennie.
    Ha N = 150, a számjegyek összege 6, és a kimenetnek "110"-nek kell lennie.
    Ha N = 147, a számjegyek összege 12, és a kimenetnek "1100"-nak kell lennie.

    Változók:
    @N egész szám
         Feltétel: 0 ≤ N ≤ 10000.
    Kimenet:
     Bináris karakterlánc
    """

def solve(N):
    """Adott egy pozitív egész szám N. Add vissza a számjegyeinek az összegét kettes számrendszerben.

    Példa
        Ha N = 1000, a számjegyek összege 1, a kimenetnek "1"-nek kell lennie.
        Ha N = 150, a számjegyek összege 6, a kimenetnek "110"-nek kell lennie.
        Ha N = 147, a számjegyek összege 12, a kimenetnek "1100"-nek kell lennie.

    Változók:
        @N egész szám
             Feltétel: 0 ≤ N ≤ 10000.
    Kimenet:
         bináris karakterlánc
    """

def solve(N):
    """Adott egy pozitív N egész szám, adja vissza számjegyeinek teljes összegét binárisan.

    Példa
        N = 1000 esetén a számjegyek összege 1 lesz, a kimenetnek "1" -nek kell lennie.
        N = 150 esetén a számjegyek összege 6 lesz, a kimenetnek "110" -nek kell lennie.
        N = 147 esetén a számjegyek összege 12 lesz, a kimenetnek "1100" -nak kell lennie.

    Változók:
        @N egész szám
             Megszorítások: 0 ≤ N ≤ 10000.
    Hozam:
         bináris számot tartalmazó karakterlánc
    """


def add(lst):
    """Adott egy egész számokból álló nem üres lista lst.
    Add össze azokat a páros elemeket, amelyeknek az indexe páratlan.
    Példa:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Adott egy nem üres egész lista lst. Adja hozzá a páratlan indexű páros elemeket.

    Példák:
        add([4, 2, 6, 7]) ==> 2
    """

def add(lst):
    """Ha adott egy nem üres lst lista, amely egész számokat tartalmaz,
    add össze a páros elemeket a páratlan indexeken.

    Példa:
    add([4, 2, 6, 7]) ==> 2
    """


def anti_shuffle(s):
    """
    Fogad egy karakterláncot, és visszaadja annak rendezett változatát.
    A karakterlánc rendezett változata olyan karakterlánc, ahol minden szó (szóközökkel elválasztva)
    helyettesítve van a karakterekkel, amelyek növekvő sorrendben vannak az ASCII értékük szerint.
    Megjegyzés: A szavak és szóközök sorrendjének meg kell maradnia a mondatban.

    Példa:
    anti_shuffle('Hi') visszaadja 'Hi'.
    anti_shuffle('hello') visszaadja 'ehllo'.
    anti_shuffle('Hello World!!!') visszaadja 'Hello !!!Wdlor'.
    """

def anti_shuffle(s):
    """
    Írj egy olyan függvényt, amelynek a bemenete egy karakterlánc, és amely
    a karakterláncot rendezetten adja vissza.
    A karakterlánc rendezett változata olyan karakterlánc, ahol minden szó (szóközzel elválasztva)
    helyébe egy olyan új szó kerül, amelyben a karakterek növekvő sorrendben szerepelnek
    az ascii értékük alapján.
    Megjegyzés: Tartsd meg a mondatban a szavak és a szóközök sorrendjét!

    Például:
    anti_shuffle('Hi') visszaadott értéke'Hi'
    anti_shuffle('hello') visszaadott értéke 'ehllo'
    anti_shuffle('Hello World!!!') visszaadott értéke 'Hello !!!Wdlor'
    """

def anti_shuffle(s):
    """
    Írjon egy függvényt, amely egy karakterláncot vesz fel, és annak rendezett változatát adja vissza.
    A karakterlánc rendezett változata olyan karakterlánc, amelyben minden szó (szóközzel elválasztva)
    helyébe egy új szó lép, ahol az összes karakter el van rendezve
    növekvő sorrendben az ascii érték alapján.
    Megjegyzés: Tartsa be a szavak és a szóközök sorrendjét a mondatban.

    Például:
    anti_shuffle('Hi') returns 'Hi'
    anti_shuffle('hello') returns 'ehllo'
    anti_shuffle('Hello World!!!') returns 'Hello !!!Wdlor'
    """


def get_row(lst, x):
    """
    Egy kétdimenziós adatot kap, beágyazott listákként,
    ami hasonló a mátrixhoz, de a mátrixoktól eltérően,
    minden sor eltérő számú oszlopot tartalmazhat.
    Adott lst és x egész szám, keresse meg az x egész számokat a listában,
    és visszaadja a sorok listáját, [(x1, y1), (x2, y2) ...] úgy, hogy
    minden sor egy koordináta - (sor, oszlopok), 0-val kezdődően.
    A koordinátákat kezdetben sorok szerint rendezze növekvő sorrendben.
    Ezenkívül rendezze a sor koordinátáit oszlopok szerint csökkenő sorrendben.

    Példák:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """

def get_row(lst, x):
    """
    2 dimenziós adatokat kapsz, beágyazott listákként,
    amely hasonló a mátrixhoz, azonban ellentétben a mátrixokkal,
    Minden sor különböző számú oszlopot tartalmazhat.
    Az lst és az x egész szám esetén keresse meg az x egész számokat a listában,
    és visszatérési lista rekordok, [(x1, y1), (x2, y2) ...] úgy, hogy
    Minden rekord egy koordináta - (sor, oszlopok), 0-tól kezdve.
    A koordinátákat kezdetben sorok szerint növekvő sorrendbe rendezheti.
    Ezenkívül rendezze a sor koordinátáit oszlopok szerint csökkenő sorrendben.

    Példák:
    get_row([
      [1,2,3,4,5,6],
      [1,2,3,4,1,6],
      [1,2,3,4,5,1]
    ], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
    get_row([], 1) == []
    get_row([[], [1], [1, 2, 3]], 3) == [(2, 2)]
    """


def sort_array(array):
    """
    Adott egy nemnegatív egész számokat tartalmazó tömb, visszaadja a tömb másolatát, amely rendezett.
    Ha az első és az utolsó indexen lévő értékek összege páratlan, rendezze a tömböt növekvő sorrendbe,
    ha az összeg páros, rendezze a tömböt csökkenő sorrendbe.

    Megjegyzés:
    * Ne módosítsa a megadott tömböt.

    Példa:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Adott egy nem negatív egész számokat tartalmazó tömb. Add vissza az adott tömb
    másolatát rendezést követően.
    A tömböt növekvő sorrendbe kell rendezni, ha a sum( first index value, last index value) páratlan,
    vagy csökkenő sorrendbe kell rendezni, ha a sum( first index value, last index value) páros.

    Megjegyzés:
    * A megadott tömböt ne változtassa meg.

    Példák:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """

def sort_array(array):
    """
    Adott egy nem negatív egész számokból álló tömb, rendezés után adja vissza az adott tömb másolatát,
    az adott tömböt növekvő sorrendbe rendezi, ha a sum( első index értéke, utolsó index értéke) páratlan,
    vagy rendezze csökkenő sorrendbe, ha a SUM( első indexérték, utolsó indexérték) páros.

    Jegyzet:
    * Ne változtassa meg az adott tömböt.

    Példák:
    * sort_array([]) => []
    * sort_array([5]) => [5]
    * sort_array([2, 4, 3, 0, 1, 5]) => [0, 1, 2, 3, 4, 5]
    * sort_array([2, 4, 3, 0, 1, 5, 6]) => [6, 5, 4, 3, 2, 1, 0]
    """