Zárthelyi és vizsga segítség

Figyelmeztetés: ez az összefoglaló nem pótolja sem a laboron elvégzett munkát, sem az előadásanyag ismeretét, sem a feladatgyűjteményből történő önálló gyakorlást.

Ezek nélkül 我们可以用中文而不是 Python 来写

A "rajzolós" feladatoknak alapvetően kétféleképpen állhatunk neki.

Az egyik megoldási módban rá kell jönnünk arra az összefüggésre, amely az ábra lényeges elemeinek sor és/vagy oszlop függését tartalmazza. Ezt legegyszerűbb lerajzolni, rajzoljunk ábrát 2-3 esetre és nem lesz túl nehéz az általában lineáris összefüggést felismerni. Ezután már csak egy ciklust kell csinálnunk a sorokra és összerakni az ábrát sztring műveletekkel.

Például a csúcsán álló háromszög esetén:

n=3           n=4         n=5

  01234     0123456     012345678
0 ooooo     ooooooo     ooooooooo
1 .ooo      .ooooo      .ooooooo  
2 ..o       ..ooo       ..ooooo
3           ...o        ...ooo
4                       ....o

A sor elején lévő szóközök száma megegyezik a sor számával, az 'o' betűk száma pedig a 0.sorban 2n-1 és soronként kettővel csökken. Azaz például:

n=int(input())
for sor in range(n):
    print(' '*sor + 'o'*(2*n-1-2*sor))

A másik megoldási mód az, hogy használjuk a koordinátageometriai ismereteinket. Ez néha egyszerűbb, néha pedig bonyolultabb kódhoz vezet. Két, egymásba ágyazott ciklust készítunk, sor illetve oszlop szerint (y ill x), majd a ciklus belsében döntjül el egy elágazással, hogy mit rajzolunk. Ne felejtsük el, hogy a belső ciklusban nem szabad új sort kezdeni, csak a külsőben. Azaz valami hasonló lesz a kódunk ebben az esetben:

n=int(input())
for y in range(n):
    for x in range(2*n):
        # ide jön az egy karaktert kiíró kód
        if x>y and x < 2*n-y:
            print('o', end='')
        else:
            print(' ', end='')
    print()

Valószínűleg az első könnyebben előállítható megoldás, mert a másodikhoz alaposan végig kellett gondolni az egyenesek egyenletét. De például a Négyzet (téglalap) rajzolása feladatnál ez a módszer lesz egyszerűbb.

Azt is megfigyelhetjük, hogy egybefüggő területeknél egyenlőtlenségek ÉS kapcsolata adja a rajzot, vonalas rajzok esetén pedig a vonalak egyenletének VAGY kapcsolatai.

Ezekben a feladatokban négy dolgot kell összekombinálni:

1. az adatszerkezet kialakítását
2. az adatok beolvasását és a hibás adatok kezelését
3. a feladat típusától függően(!) az adatok feldolgozását
4. az eredmények megjelenítését.

Nézzük őket sorban!

Adatszerkezet kialakítása

Számláló jellegű feladatok esetén (minimum, maximum, darabszám, összeg, átlag stb.) nem kell az összes adat, tehát nem is tároljuk. Ki kell találjuk a leképezést egy listára, ha átnézed és elolvasod az eddigi feladatokat akkor szinte mindent láttál már:

Feladat	Tároló	Leképezés
Dolgozat pontszámai	[0]*(max pontszám+1)	[pontszám]
Egész számok	[0]*(legnagyobb-legkisebb+1)	[szám-legkisebb]
Kockadobások (2 kocka)	[0]*(12-2+1)	[összeg- 2]
Autópálya bírságok	[0]*24	[óra]
Autópálya forgalmi statisztika	[0]*(maxsebesség//10)	[sebesség // 10]
Nagybetűk megszámolása	[0]*(ord('Z')-ord('A')+1)	[ord(betu)- ord('A')]

Nézd át és értsd meg az adatszerkezet kialakításának okait és azt, hogy hogyan címezzük a listát, valamint kijelzésnél hogyan lesz a forrásadatnak megfelelő adat a lista indexéből.

Ezután válaszold meg magadban, hogy milyen adatszerkezetet használnál és hogyan történik az elérés a Feladatgyűjtemény megadott példáin! (Ha kiválasztod egérrel, látható lesz a válasz.)

Feladat	Tároló	Leképezés
Statisztika a számokról	[0]*10	[szam]
Kódtörő II	[0]*10	[ord(szamjegy)-ord('0')], [int(szamjegy)]
ZH statisztika I	[0]*4	[ord(csoport)-ord('A')]
ZH statisztika II.	[0]*31	[pont]
Múzeum I.	[0]*6	[nap]
Múzeum II.	[0]*6, [0]*7	[nap-1] , [nap]
Autópálya I.	[0]*24	[ora]
Autópálya II.	[0]*24	[ora]
Bliccelés I.	[0]*48	[ora*2+perc//30]
Bliccelés II.	[0]*24	[ora]

Nem kell feltétlenül a lehető legkevesebb memóriáhasználatra törekedni. Pl. a hónapok hosszának tárolásához nyugodtan használhatunk egy 13 elemű tömböt, ahol a nulladik elemet nem használjuk, így egyszerűen tudjuk a hónap sorszámával címezni, és nincs szükség 1 levonására, így nem is tudunk elfelejtkezni róla. Egy egész számnak megfelelő memória pedig elhanyagolható.

Beolvasás

Olvassuk be az adatokat a bemenetről, az adatok végét üres sor jelzi.

sor=input()
while sor!="":
    ## ellenőrzés
    ## feldolgozás vagy tárolás
    sor= input() # <-- figyelni kell, nehogy lemaradjon a végéről!

Jobb megoldás a break használata, picit logikusabb, hogy az input után van az ellenőrzés, és ha az sikeres a feldolgozás/tárolás

while True: # végtelen ciklus
    sor= input()
    if sor=="":
        break
    ## ellenőrzés
    ## feldolgozás vagy tárolás

Olvassunk fájl vége jelig!

while True: # végtelen ciklus
    try:
        sor= input()
        ## ellenőrzés
        ## feldolgozás vagy tárolás
        ## ami kivételt is dobhat, azt majd külön kezelni kell
    except EOFError:
        break

Olvassunk fájl vége jelig, ha hiba történik, írjuk ki a hibás sort, de haladjunk tovább

while True: # végtelen ciklus
    try:
        sor= input()
            ## ellenőrzés
            ## feldolgozás vagy tárolás
    except ValueError:
        print(f"Hiba történt: {sor}")
        continue # itt pont felesleges, de jelzi a szándékot
    except EOFError:
        break

stb.

Feldolgozás

Ez teljesen feladatfüggő. A leírásnak megfelelően darabolnunk kell esetleg beolvasott sort, egésszé vagy lebegőpontos számmá konvertálni az adatokat, majd az adatszerkezetet feltölteni vagy előállítani a bejövő adatokból valamilyen számolt adatot, amivel a tároló listánkat vagy címezni fogjuk, vagy más módon felhasználjuk.

Pl. kockadobások összege:

osszeg= random.randint(1,6) + random.randint(1,6)
db[osszeg -2] +=1 

Csoportok szerinti dolgozatok példáinak összegzése:

darabolt= sor.split()
csoport= sor[0]
pont= 0
for i in range(1, len(darabolt)):
    pont+= int(darabolt[i])

Adatok megjelenítése

Itt is két választásunk van, használhatjuk a listaelemeket, de ekkor a leképezés inverzével kell a forrásadatot előállítani. Pl. a betűk számolásánál:

for i in range(len(tarolo)):
    kar= chr(i+ord('A'))
    if tarolo[i] != 0:
        print(f"{kar}: {tarolo[i]})")

Csinálhatunk ciklust az eredeti adatokkal és visszaszámoljuk az indexet, mint amikor a listát töltöttük fel, pl. az autópályánál a sebesség számolása

for sebesseg in range(0, 200, 10):
    ertek= db[sebesseg//10]
    print(f"{sebesseg:>3}-{sebesseg+9:>3} {ertek}")

A kijelzés feldobhatjuk hisztogrammal:

    hist= '#' * (ertek*50//maxertek)

ahol a maxertek a maximális érték és ez lesz 50 karakter hosszú.

stb.