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

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