A programozás alapjai (üzemmérnök informatikus) 2019 NZH megoldások forrásának megtekintése

===1. feladat: ProgAlap eredmények===

    def osztalyoz(pont):
        if (pont <= 39):
            return 1
        if (pont <= 54):
            return 2
        if (pont <= 69):
            return 3
        if (pont <= 84):
            return 4
        return 5
     
    def main():
        db = [0] * 5
     
        sor = input()
        while sor != "":
            pont = int(sor)
            db[osztalyoz(pont)-1] += 1
            sor = input()
     
        for jegy in range(1, 5+1):
            print('{} {:3} {}'.format(jegy, db[jegy-1], '*' * db[jegy-1]))
     
        print('átment {} fő'.format(sum(db[1:])))
     
    main()
    
Pontozás:

* függvény (ha nem pont ez a paraméterezés/érték, mind elveszik): fejléc
* pont-jegy átalakítás, visszatérési érték előállítása
* főprogram, adatok kezelése: beolvasás végjelig, üres sor
* int átalakítás, ami a végjelre nem történik meg
* adatszerkezet (5 vagy 6 elemű lista)
* pontszám leképezése tömbelemre, számlálók növelése
* főprogram, eredmény kiírása: megfelelően paraméterezett for vagy while ciklus
* jegy és létszámok kiírása
* csillagok kiírása
* átment (elégséges...jeles): szummázás

===2. feladat: A kapitány===

    def hany_osztoja_van(szam):
        db = 0
        for oszto in range(1, szam + 1):
            if szam % oszto == 0:
                db += 1
        return db
     
    def van_benne(szam, szamjegy):
        while szam > 0:
            if szam % 10 == szamjegy:
                return True
            szam //= 10
        return False
     
    def main():
        ev = 2018
        while not (hany_osztoja_van(ev) == 8 and van_benne(ev, 7)):
            ev -= 1
        print("Születés: {}, életkor: {}".format(ev, 2019-ev))
     
    main()
    
Pontozás:

* hány osztója van függvény: fejléc, paraméterezés (egész szám) és visszatérési érték (egész szám minden ágon)
* számlálás algoritmusa (db kezdetben nulla, néha nő)
* osztókat számlál, modulót használ, 1-et és a számot is beleérti
* van benne adott számjegy: fejléc, paraméterezés (két egész szám), visszatérési érték (logikai típus minden ágon)
* True érték, ha van, False érték, ha sehol nincs
* összes számjegyet megvizsgálja
* ki tud venni egy számjegyet (modulo 10)
* évszám megkeresése: 2019-től visszafelé megy a ciklus az első találatig, nincs tárolás, nincs maxkeresés
* megáll a találatnál, és az év/egyéb változóban tényleg jó számot ír ki
* kiírja az eredményt, a születési évszámot és az életkort is

===3. feladat: Egyformák, éppen a duplája===

    import random
     
    def szaz_veletlenszam():
        szamok = []
        for _ in range(100):
            szamok.append(random.randint(1, 1000))
        return szamok
     
    def van_ismetlodes(szamok):
        for i in range(0, len(szamok) - 1):
            if szamok[i] == szamok[i + 1]:
                return True
        return False
     
    def egyik_masiknak_duplaja(szamok):
        db = 0
        for i in range(0, len(szamok) - 1):
            for j in range(i + 1, len(szamok)):
                if szamok[i] * 2 == szamok[j] or szamok[i] == szamok[j] * 2:
                    db += 1
        return db
     
    def main():
        sz = szaz_veletlenszam()
        if van_ismetlodes(sz):
            print("Van ismétlődés")
        else:
            print("Nincs ismétlődés")
        print(egyik_masiknak_duplaja(sz), "duplás pár van")
     
    main()
    
Pontozás:

* száz véletlenszám: random.randint vagy randrange helyes használata, van import random
* beteszi a számokat a listába
* van-e ismétlődés: egymás melletti számokat vizsgál, nem indexel túl
* ciklus végig a listán, végig is megy, ha nincs találat
* megáll a keresés az első találatnál
* egyik a másiknak duplája: megszámlálás algoritmusa (db = 0, if ... db + 1, return db)
* ciklus minden számhoz
* ciklus minden *további* számhoz, saját maga nem, előzőek nem
* figyelembe veszi, hogy a sorrend nem számít (pl. 50-100 és 100-50 is jó)
* főprogram: helyesen használja a függvényeit

===4. feladat: Dráma!===

    # a mintamegoldás a tanult sztringkezelő függvényeket használja,
    # de ciklusokkal megírt keresés is teljesen jó. akár regex is.
    def atalakit(sor):
        kettospont = sor.find(':')
        if kettospont == -1:
            raise ValueError("Nincs kettőspont a sorban")
        nev = sor[:kettospont]
        szoveg = sor[kettospont+1:]
        szoveg = szoveg.strip()
        return "<" + nev + "> " + szoveg
     
    def main():
        while True:
            sor = input()
            if sor == "":
                break
            try:
                ujformatum = atalakit(sor)
                print(ujformatum)
            except:
                pass
     
    main()
    
Pontozás:

* átalakítás: kettőspont megkeresése
* ha nincs kettőspont, kivétel dobása
* név kivágása, figyelve, hogy a kettőspont már ne kerüljön bele
* szöveg kivágása, ne kerüljön bele a kettőpont
* vezető szóközök levágása a szövegből. működjön, ha nincs szóköz.
* új, kacsacsőrös formátum összeállítása
* főprogram: beolvasás üres végjelig, sorig
* átalakító fv hívása
* kivétel elkapása, kezelése (elkapni kell, de teendő nincs)
* eredmény kiírása, ez a főprogramban kell legyen, nem az átalakítóban