Kategória: Python gyerekeknek.

Az alábbi feladatok mindegyike megoldható a következő építőkockák segítségével:

• Kiírás és beolvasás
• Változók és műveletek
• Feltételkezelés
• Ciklusok
• Adatszerkezetek
• Függvények

További gyakrolási lehetőségek:

• https://www.hackerrank.com/domains/python: világszerte ismert és elismert rendszer, ahol mindenféle programozási nyelven találunk feladatokat. Ott helyben kell megoldani, és ki is értékeli azonnal. Angolul van.
• https://www.w3resource.com/python-exercises/: több száz Python feladat megoldással.

Szökőév

Feladat

Készítsünk egy függvényt, ami meghatározza, hogy egy adott év szökőév-e!

Elemzés

Először is nézünk utána, mikor számít egy év szökőévnek!

• Ha az év nem osztható néggyel, akkor nem szökőév.
• Ha az év osztható néggyel, de nem osztható százzal, akkor szökőév.
• Ha az év osztható százzal, de nem osztható négyszázzal, akkor nem szökőév.
• Ha az év osztató négyszázzal, akkor szökőév.

Az egyszerűség érdekében tekintsünk el néhány dologtól:

• Ezt a rendszert 1582-ben vezették be, az azt megelőző időszakra nem érvényes. Előtte csak a néggyel oszthatóság számított.
• A protestáns országok csak 1700-ban vezették be a rendszert.
• A görögkeleti országok csak jóval később vezették be, sőt, maguk az egyházak még ma sem.
• A nem keresztény országok egy jelentős csoportja más időszámítást használ.

Forma

• Függvény neve: szokoev
• Paraméterei:
  • n: évszám, pl. 2021
• Visszatérési értéke: logikai, ami igaz akkor, ha szökőév, hamis, ha nem. Ebben a példában hamis.

Megoldás

def szokoev(n):
    if n % 4 != 0:
        return False
    elif n % 400 == 0:
        return True
    elif n % 100 == 0:
        return False
    else:
        return True

Tesztelés

print(szokoev(2021)) # False
print(szokoev(2020)) # True
print(szokoev(1900)) # False
print(szokoev(2000)) # True

Legnagyobb közös osztó

Feladat

Készítsünk egy függvényt, ami meghatározza két pozitív egész szám legnagyobb közös osztóját.

Elemzés

A legnagyobb közös osztó meghatározásához érdemes az ún. Euklideszi algoritmust használni (https://hu.wikipedia.org/wiki/Euklideszi_algoritmus). Ennek lényege a következő: addig vonjuk ki a nagyobb számból a kisebbet, amíg a két szám egyenlő nem lesz; az eredmény a legnagyobb közös osztó.

Az egyszerűség érdekében nem ellenőrizzük, hogy a kapott értékeke pozitív egészek-e.

Forma

• Függvény neve: lnko
• Paraméterei:
  • a: az egyik egész szám, pl. 30
  • b: a másik egész szám, pl. 12
• Visszatérési értéke: egy egész szám, a két szám legnagyobb közös osztója. Ebben a példában 6.

Megoldás

def lnko(a, b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return a

Tesztelés

print(lnko(30, 12)) # 6
print(lnko(77, 24)) # 1
print(lnko(77, 7)) # 7
print(lnko(77, 77)) # 77

Legkisebb közös többszörös

Feladat

Írjunk egy függvényt, ami meghatározza két pozitív egész szám legkisebb közös többszörösét.

Elemzés

Visszavezetjük a legnagyobb közös osztóra. Két szám legkisebb közös többszöröse azok szorzata, osztva a legnagyobb közös osztóval. Itt sem ellenőrizzük a bemenő paramétereket, hanem feltételezzük, hogy jók.

Forma

• Függvény neve: lkkt
• Paraméterei:
  • a: az egyik egész szám, pl. 30
  • b: a másik egész szám, pl. 12
• Visszatérési értéke: egész szám, a két szám legkisebb közös többszöröse. Ebben a példában 60.

Megoldás

def lnko(a, b):
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return a
 
def lkkt(a, b):
    o = lnko(a, b)
    return a * b // o

Tesztelés

print(lkkt(30, 12)) # 60
print(lkkt(77, 24)) # 1848
print(lkkt(77, 7)) # 77
print(lkkt(77, 77)) # 77

Prím ellenőrzés

Feladat

Írjunk egy függvényt, ami meghatározza, hogy a paraméterül kapott pozitív egész szám prím-e.

Elemzés

Prím az a pozitív egész szám, melynek saját magán és az 1-en kívül nincs más osztója. Tehát egy ciklusban egyesével 2-től a paraméter mínusz 1-ig megvizsgáljuk, hogy osztója-e, azaz 0-e az osztás maradéka. Ha találunk ilyet, azonnal visszatérünk False-szal. Ha végigfutott a ciklus, akkor a szám prím, így ekkor True-val térünk vissza.

Forma

• Függvény neve: prim
• Paraméterei:
  • n: egy pozitív egész szám, amiről meg szeretnénk tudni, hogy prím-e, pl. 7.
• Visszatérési értéke: logikai. Igaz, ha prím, hamis, ha nem prím. Ebben a példában igaz.

Megoldás:

def prim(n):
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

Tesztelés

print(prim(2)) # True
print(prim(6)) # False
print(prim(7)) # True

Továbbgondolás

import math
 
def prim(n):
    for i in range(2, round(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True
 
print(prim(2932031007403)) # True

def prim(n):
    i = 2
    while i*i <= n:
        if n % i == 0:
            return False
        i = i + 1
    return True
 
from datetime import datetime
before = datetime.now()
print(prim(2932031007403))
after = datetime.now()
print(after-before)

Fibonacci

Feladat

Írjunk egy függvényt, ami egy pozitív egész számot vár paraméterként, és az adott sorszámú Fibonacci számot adja vissza.

Elemzés

Az első és a második Fibonacci szám 1, míg minden további az előző kettő összege. Így az első pár Fibonacci szám a következő: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 stb. A feladatot többféleképpen oldjuk meg; ebből az első a "rendes" megoldás, a többi viszont inkább érdekesség.

Forma

• Függvény neve: fibonacci
• Paraméterei:
  • n: egy pozitív egész szám, ami a kérdéses sorszámú Fibonacci szám sorszáma, pl. 6.
• Visszatérési értéke: egy pozitív egész szám, a paraméterül kapott sorszámú Fibonacci szám. A példában 8.

Megoldás

def fibonacci(n):
    a = 0
    b = 1
    for i in range(n):
        temp = b
        b = a + b
        a = temp
    return a

Tesztelés

print(fibonacci(1)) # 1
print(fibonacci(2)) # 1
print(fibonacci(3)) # 2
print(fibonacci(4)) # 3
print(fibonacci(5)) # 5
print(fibonacci(6)) # 8
print(fibonacci(40)) # 102334155

Továbbgondolások

def fibonacci(n):
    if n < 2:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

def fibonacci(n):
    def fibonacci_recursion(n):
        if fibonacci_array[n] is not None:
            return fibonacci_array[n]
        if n < 2:
            fibonacci_array[n] = n
            return n
        else:
            result = fibonacci_recursion(n-1) + fibonacci_recursion(n-2)
            fibonacci_array[n] = result
            return result
 
    fibonacci_array = [None] * (n+1)
    return fibonacci_recursion(n)

def fibonacci(n, a=0, b=1):
    if n == 0:
        return a
    elif n == 1:
        return b
    else:
        return fibonacci(n-1, b, a+b)

Rendezés

Feladat

Egy lista elemeit rendezzük sorba.

Elemzés

A Pythonban a rendezés már meg van valósítva. A feladat nem az, hogy a megvalósított rendezést alkalmazzuk, hanem mi magunk valósítsunk meg egy rendezést.

Az egyik legegyszerűbb rendezés módszer az úgynevezett buborék rendezés. Ennek a lényege: végigmegyünk a listán, és ha találunk két szomszédos, rossz sorrendben levő elemet, akkor felcseréljük. Majd miután végeztünk, megismételjük, egészen addig, amíg történik csere. Ha nem történt csere, az azt jelenti, hogy az elemek sorban vannak.

Az ok, ami miatt buborékrendezés a neve, személetes: ha a lista elemeit úgy képzeljük el, mintha egy csőbe lennének belerakva, amit felállítunk úgy, hogy az eredetileg fekvő cső jobb oldala kerül le, a bal oldala pedig fel, akkor a módszer hatására a "könnyű" (azaz kis) elemek "felfele szállnak", míg a "nehéz" (azaz nagy) elemek meg lefelé.

Forma

• Függvény neve: rendez
• Paraméterei:
  • l: lista, amit rendezni szeretnénk. Az egyszerűség érdekében a lista elemei legyenek pozitív egészek, pl. [4, 2, 6, 7, 3, 5].
• Visszatérési értéke: nincs. A bemenetül kapott lista lesz rendezve. A példában [2, 3, 4, 5, 6, 7].

Megoldás

def rendez(l):
    modified = True
    while modified:
        modified = False
        for i in range(len(l)-1):
            if l[i] > l[i+1]:
                temp = l[i]
                l[i] = l[i+1]
                l[i+1] = temp
                modified = True

Tesztelés

lista = [4, 2, 6, 7, 3, 5]
rendez(lista)
print(lista) # [2, 3, 4, 5, 6, 7]

Továbbgondolások

lista = [4, 2, 6, 7, 3, 5]
lista.sort()
print(lista) # [2, 3, 4, 5, 6, 7]

Kerekítés

Feladat

Írjunk egy olyan függvényt, ami egy számot adott értékre kerekít, pl. százasokra.

Elemzés

A függvény két paramétert vár: az egyik maga a szám lesz, a másik pedig azt jelzi, hogy hányasokra kerekítsünk. Pl. a 0 jelentse azt, hogy egyesekre, az 1 azt, hogy tízesekre, a 2 azt, hogy százasokra stb. Ez a szám tehát azt mondja meg, hogy az eredményben legalább hány nulla lesz a végén. 5 alatt lefelé, 5-től felfelé kerekítünk. (Ez itt a szokás. Amikor én diák voltam, az 5-re végződőt páros irányba kerekítettük, tehát néha le, néha fel.) Ne használjuk ki a round() és egyéb kerekítő függvényeket, csak az int()-et, ami a paraméterül kapott értéknek mindig lefelé kerekítve adja vissza az egész részét.

A megoldás módszere a következő: először megfelelő számszor elosztjuk 10-zel a kerekítendő számot (pl. ha a második paraméter 2, akkor kétszer, ezáltal százzal osztjuk). Ott megnézzük, hogy a tört rész legfeljebb 4 vagy legalább 5-e. A tört részt úgy határozzuk meg, hogy kivonjuk a számból az int() által visszaadott egész részt. Tehát a tört rész értékétől függően kerekítünk vagy lefelé vagy felfelé. Végül megszorozzuk annyiszor 10-zel, ahányszor osztottunk az elején.

Forma

• Függvény neve: kerekit
• Paraméterei:
  • n: pozitív szám, amit kerekíteni szeretnénk, pl. 249.
  • z: a végeredményben a nullák minimális száma, pl. 2.
• Visszatérési értéke: a kerekített szám. A példában 200.

Megoldás

def kerekit(n, z):
    for i in range(z):
        n = n / 10
    if n - int(n) < 0.5:
        n = int(n)
    else:
        n = int(n) + 1
    for i in range(z):
        n = n * 10
    return n

Tesztelés

print(kerekit(2.4, 0)) # 2
print(kerekit(2.5, 0)) # 3
print(kerekit(2.6, 0)) # 3
 
print(kerekit(24, 1)) # 20
print(kerekit(25, 1)) # 30
print(kerekit(26, 1)) # 30
 
print(kerekit(249, 1)) # 250
print(kerekit(250, 1)) # 250
print(kerekit(251, 1)) # 250
 
print(kerekit(249, 2)) # 200
print(kerekit(250, 2)) # 300
print(kerekit(251, 2)) # 300

Átlag számoló

Feladat

Számoljuk ki egy tantárgy esetén a végső osztályzatot az átlag alapján, de úgy, hogy ne vegye figyelembe a legrosszabb és a legjobb osztályzatot.

Elemzés

Kihasználhatjuk a Python által nyújtott lehetőségeket. Tegyük fel, hogy l egy lista, r pedig egy valós szám:

• sum(l): összeg
• min(l): minimum elem
• max(l): maximum elem
• len(l): lista hossza
• round(r): kerekítés

Forma

• Függvény neve: atlag
• Paraméterei:
  • jegyek: 1 és 5 közötti egészekből álló lista. Feltételezzük, hogy legalább 3 elemű. Pl. [1, 5, 5, 5].
• Visszatérési értéke: egy egész szám, a paraméterül kapott számok fenti szabály szerinti átlaga, kerekítve. A példában 5.

Megoldás

def atlag(jegyek):
    osszeg = sum(jegyek) - max(jegyek) - min(jegyek)
    atlag = osszeg / (len(jegyek)-2)
    return round(atlag)

Tesztelés

print(atlag([4, 4, 4, 4])) # 4
print(atlag([1, 5, 5, 5])) # 5
print(atlag([1, 1, 1, 5])) # 1
print(atlag([4, 4, 4, 5, 5, 5])) # 5

Leggyakoribb elem

Feladat

Egy listából válasszuk ki azt, amelyik legtöbbször fordul elő.

Elemzés

Ezt a feladatot szótár (dict) segítségével oldjuk meg:

• A szótár kulcsai a lista különböző elemei, az értékei pedig az, hogy hányszor fordulnak elő.
• Az első részben felépítjük a szótárat.
  • Üres szótárból indulunk ki.
  • Végig lépkedünk az elemeken.
  • Ha van már olyan kulcsú elem, akkor növeljük az értékét; ha nincs, akkor egyre állítjuk be.
• Végig lépkedünk a szótáron, és a legnagyobb értékű elemhez tartozó kulcs lesz az eredmény.
• Ha több megoldás van, akkor egyet adunk vissza.

Forma

• Függvény neve: leggyakoribb
• Paraméterei:
  • l: egész számokból álló lista, pl. [4, 3, 5, 4, 5, 5].
• Visszatérési értéke: egy egész szám a paraméterül kapott listából, ami legtöbbször fordul elő. A példában ez 5.

Megoldás

def leggyakoribb(l):
    elemek = {}
    for i in l:
        if i in elemek:
            elemek[i] = elemek[i] + 1
        else:
            elemek[i] = 1
    max_gyakorisag = -1
    eredmeny = -1
    for k in elemek:
        if elemek[k] > max_gyakorisag:
            max_gyakroisag = elemek[k]
            eredmeny = k
    return eredmeny

Tesztelés

print(leggyakoribb([4, 3, 5, 4, 5, 5])) # 5

Számjegyek összege

Feladat

Számoljuk ki egy paraméterül kapott egész szám számjegyeinek az összegét.

Elemzés

A feladat nem is annyira egyszerű, mint amilyennek látszik első látásra! Persze nem is annyira bonyolult, mint amilyennek látszik másodikra :-) A megoldás: a számnak a 10-zel vett maradékát adjuk hozzá a részeredményhez, miközben osztjuk a számot 10-zel. Ezt addig csináljuk, amg a szám "el nem fogy". Ügyeljünk arra, hogy az egész osztást használjuk (//) a lebegőpontos osztás helyett (/)!

Forma

• Függvény neve: szamjegyek_osszege
• Paraméterei:
  • n: egy pozitív egész szám, pl. 123.
• Visszatérési értéke: egy pozitív egész szám; a paraméterül kapott szám számjegyeinek összege. A példában 6.

Megoldás

def szamjegyek_osszege(n):
    eredmeny = 0
    while n > 0:
        eredmeny = eredmeny + n % 10
        n = n // 10
    return eredmeny

Tesztelés

print(szamjegyek_osszege(123)) # 6
print(szamjegyek_osszege(1000)) # 1
print(szamjegyek_osszege(9999)) # 36