<jupyter_start><jupyter_text>mbence Definiálunk egy függvényt amely egy stringekből álló tömböt vár paraméterként, és visszatérési értéke egész szám, azaz integer. Deklarálunk 2 változót. amelyeket kezdőértékkel látunk el. Egy for ciklus segítségével 0-tól a paraméterként kapott lista hosszáig iterálunk. A ciklusmagon belül deklarálunk egy további változót, amit ugyancsak kezdőértékkel látunk el. Mindezek után egy másik for ciklussal amellyel a tömb egyes stringjeit járjuk be. A beágyazott ciklusban egy elágazást manifesztálunk, amely egy VAGY logikai kapcsolattal ellátott feltételt ellenőriz. A feltétel teljesülése esetén egy értékadás történik, a külső ciklusmagban deklarált (2. mondat) változón. A belső ciklus lefutása után egy elágazás feltételeként összehasonlítjuk a függvénytörzsben létrehozott változót a beágyazott ciklusban módosított változóval. Minden esetben a nagyobb értékű változó ad értéket a függvénytörzsben lévő változónak. A függvénytörzsben létrehozott másik változóban, eltároljuk a külső ciklus jelenlegi indexét. A folyamat végén az eltárolt pozíciót visszaadjuk.<jupyter_code>def mbence_solution(block_of_strings):
    a = 0
    b = 0
    for i in range(len(block_of_strings)):
        c = 0
        for i in range(str in block_of_strings)
    # modify this function
    # return value and parameters and all
    return 0
mbence.evaluate(mbence_solution)<jupyter_output><empty_output><jupyter_text>dani<jupyter_code>def dani_solution():
    # modify this function
    # return value and parameters and all
    return 0
dani.evaluate(dani_solution)<jupyter_output><empty_output><jupyter_text>bogi Úgy indulunk, hogy van egy list_of_numbers nevű listám. Először deklarálom a result változót és 0 értéket adok neki. Aztán a list_of_numbers listából halmazt alakítok, majd ezt vissza alakítom listává. Ezután írok egy for ciklust: a ciklus végigiterál a lista elemein azon feltételek szerint, hogy a lista eleme páratlan és pozitív. Amely elemeknél ezek a feltételek teljesülnek, azokat hozzáadom a result változóhoz. Végül meghívom a result visszatérési értékét<jupyter_code>def bogi_solution(list_of_numbers):
    result = 0
    set_of_numbers = set(list_of_numbers)
    list_of_numbers2 = list(set_of_numbers)
    for i in range(len(list_of_numbers2)):
        if list_of_numbers2[i]%2==1 and list_of_numbers2[i] > 0:
            result += list_of_numbers2[i]
    return result
    # modify this function
    # return value and parameters and all
bogi.evaluate(bogi_solution)<jupyter_output>- success rate: 497/497 (100.0%)
- error count: 0
- best performance: 1
- worst performance: 1
- mean performance: 1.0<jupyter_text>katinka * Definiálok egy függvényt, melynek egy integer lista típusú paramétere van.* Az első utasítás során a bemeneti értékeket/listát sorrendbe rendezi a program, csökkenő sorrendben.* Ezután definiálok egy új változót ("a"), melynek a 0 értéket adom.* Definiálok ezt követően egy újabb változót ("b"), mely meghívja a rendezett lista "a"-dik elemét, majd egy listát csinál a ennek az elemnek a számjegyeiből azon feltétel mellett, hogy az integer nem negatív (nem tartalmazza a "-" jelet).* Ezután egy olyan ciklust hozok létre, mely azt vizsgálja, hogy a "b" lista nem egyenlő-e a "b" lista növekvő sorrendbe állított változatával. A "True" elágazás mentén továbbhaladva a függvényt utasítom, hogy növelje eggyel az "a" értékét, azonban ha már a növelt érték nagyobb lenne, mint az eredeti listám elemszáma, a visszatérési érték 0. Ha még nem nagyobb, akkor módosítsa a "b" listát az "a" elemszámainak megfelelő listává a már korábbiak szerint. A "False" elágazás mentén pedig a visszatérési érték a legutóbbi "a".<jupyter_code>def katinka_solution(input_list):
    # modify this function
    # return value and parameters and all
    list2 = sorted(input_list, reverse = True)
    a = 0
    if list2[a] >= 0:
        b = list(str(list2[a]))
    while sorted(b) != b:
        a += 1
        if a >= len(list2):
            return 0
        else:
            b = list(str(list2[a]))
    return list2[a]
katinka.evaluate(katinka_solution)<jupyter_output>- success rate: 497/497 (100.0%)
- error count: 0
- best performance: 1
- worst performance: 1
- mean performance: 1.0<jupyter_text>keve find the number of strings in a list of strings that contain a given letterupper or lower case> ```["abfg", "Bcd", "Ijk"], "b" -> 2```<jupyter_code>def keve_solution(list_of_strings, letter):
    # modify this function
    # return value and parameters and all
    return 0
keve.evaluate(keve_solution)<jupyter_output><empty_output><jupyter_text>dorka Először definiálom a függvényt, amelynek 2 paramétere van az egyik egy lista, amiben szavak vannak, a másik paramétere pedig egy betű. Utána a változóknak adok egy értéket, melyben azt mondom, hogy az első változó értéke üres szó, a második változó értéke pedig a 0. Ezután egy for ciklus segítségével végigmegyünk a szavak listáján az elejétől a végéig. A ciklusban a program megszámolja, hogy egy szóban egy betű hányszor szerepel, közben azt kiküszöbölve, hogy a szavakban vegyesen vannak kis és nagybetűk, mivel a függvényem minden betűt naggyá alakít. Itt következik egy if feltétel, mely szerint ha a kapott szám nagyobb, mint 0, akkor ez lesz az "új" legnagyobb szám és a következőkben már ehhez hasonlítja a többi szóban szereplő előfordulást. A végén a függvényem visszatérési értéke egy szó lesz, azaz egy string.<jupyter_code>def dorka_solution(list_of_words, letter):
    a = ""
    b = 0
    for i in range(len(list_of_words)):
        list_of_words[i] == upper(list_of_words[i])


    # modify this function
    # return value and parameters and all
    return 0
dorka.evaluate(dorka_solution)<jupyter_output><empty_output><jupyter_text>eszter A függvényem a következő képpen épül fel: először is definiálom a függvényt: 2 paramétere van, egy lista adat és egy integer. Ez után értéket adok egy új listának, amin belül indítok egy for ciklust, ami a a függvény paraméterei között deklarált lista elemein iterál végig elemről elemre és itt van egy if elágazás, ami az egyes elemeket és a paraméterként deklarált integerrel számít. Ismét van egy if elágazás, ami a második listát vizsgálja, majd van egy else ág, hogy visszakapjam a megfelelő értékeket.<jupyter_code>def eszter_solution(input_list, input_int):
    list2 = []
    for i in range(len(input_list)):
        for i in range(input_list):
            list2 = (input_list[i], input_int)
        if
    # modify this function
    # return value and parameters and all
    return 0
eszter.evaluate(eszter_solution)<jupyter_output><empty_output><jupyter_text>szabi A program a következő módon működik:Először definiálok egy függvényt (egy paraméterrel, ami a bemenő számok listája), majd deklarálok egy üres listát.Ezután létrehozok egy for ciklust, ami végighalad a bemenő számok listáján. A ciklusmagbanegy elágazással vizsgálom, hogy az adott szám (amit a bemenő listából épp vizsgálok) kétszerese szerepel-e a bemeneti listában.Amennyiben a feltétel teljesül, az adott számot hozzátoldom a korábban létrehozott üres listához.Végül egy újabb elágazás segítségével (már a cikluson kívül) határozom meg a visszatérési értéket. Ha annak a listának a hossza, amelyben az elemeket gyűjtöm 0 (tehát nem volt olyan szám, amelynek szerepelne a kétszerese a bemeneti listában), akkor a visszatérési érték 0. Ha a vizsgált lista hossza nem 0, akkor a visszatérési érték annak listának a legkisebb eleme, amelybe az elemeket gyűjtöttem.<jupyter_code>def szabi_solution(list_of_numbers):
    list2 = []
    for i in range(len(list_of_numbers)):
        if 2*list_of_numbers[i] in (list_of_numbers):
            list2.append(list_of_numbers[i])
    if len(list2) == 0:
        return 0
    else:
        return min(list2)
    # modify this function
    # return value and parameters and all
    return 0
szabi.evaluate(szabi_solution)<jupyter_output>- success rate: 497/497 (100.0%)
- error count: 0
- best performance: 1
- worst performance: 1
- mean performance: 1.0<jupyter_text>hako<jupyter_code>def hako_solution():
    # modify this function
    # return value and parameters and all
    return 0
hako.evaluate(hako_solution)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.06104827921683084, 'fraction_numerical': 0.011917791560257813, 'mean_word_length': 4.564276048714479, 'pattern_counts': {'":': 0, '<': 34, '<?xml version=': 0, '>': 39, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '424365', 'license': 'MIT', 'n_tokens_mistral': 3302, 'n_tokens_neox': 3297, 'n_words': 981, 'path': 'members/dani/7_hazi/round2.ipynb', 'repo_name': 'Rajk-Prog1/prog1_2021_fall', 'size': '8223'}