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

A VIK Wikiből
A lap korábbi változatát látod, amilyen Bogyó Sándor Lóránt (vitalap | szerkesztései) 2019. december 1., 13:29-kor történt szerkesztése után volt. (Új oldal, tartalma: „===1. feladat: ProgAlap eredmények=== def osztalyoz(pont): if (pont <= 39): return 1 if (pont <= 54): return 2 if…”)
(eltér) ← Régebbi változat | Aktuális változat (eltér) | Újabb változat→ (eltér)
Ugrás a navigációhoz Ugrás a kereséshez

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