A haladási napló kérdései 2018-ban

Adatok, adattípusok, változók

0. Nem találkoztam ezekkel a fogalmakkal programozás során
1. Mutatták, hogy hogyan kell változót definiálni, ha kell, én is meg tudom írni.
2. A feladatok megoldásának (néha nehéz) része, hogy ki kell gyűjtenem, milyen int, double, char... változók kellenek, milyen adatokat kell tárolnia a programnak.
3. A feladat olvasásakor még nem látom, hogy milyen változókra lesz szükségem, de az egyes részeket újra elolvasva könnyű kigyűjteni őket.
4. A feladat első elolvasása után már tudom, hogy milyen típusú egyszerű illetve összetett változókra lesz szükségem a kapott adatok illetve az eredmény tárolásához.
5. A feladat "scannelése" (ránézésre, néhány szó elolvasása) elég ahhoz, hogy nagyjából tudjam, milyen típusú és struktúrájú változókra lesz szükségem a bemenő adatok és az eredmény tárolásához.

Algoritmus

0. Nem hallottam még algoritmusról
1. Meg tudom fogalmazni, hogy egymás után mit várok el a megírandó programtól. (Pl. ki kell számolni az összeget, utána ki kell írni a képernyőre az eredményt)
2. Tudok olyan feladatokra programokat írni, amiben egymás után kell utasításokat adni. (Pl. két szám összeadása, koordinátákkal megadott vektor hosszának számítása)
3. Meg tudok oldani olyan feladatokat, amelyben többszörös elágazás van vagy egy cikluson belül kell elvégezni egy műveletet. (Pl. másodfokú egyenlet megoldása, 1000-nél kisebb négyzetszámok kiírása.)
4. A feladatok megoldása során az elvégzendő lépéseket vezérlési szerkezetekre lebontva fogalmazom meg. Az ismétlés hossza különböző feltételektől függhet, cikluson belül lehetnek újabb feltételek vagy újabb ciklus (azért módjával...)
5. A feladatok megoldását tipizálom, pl. beszúrás, keresés, kiválogatás, gráfbejárás... Ezek algoritmusát (a vezérlési szerkezetek összetett alkalmazását) fejből tudom, csak az adott feladatra adaptálásán kell gondolkodnom.

Kódolás

0. Nem tudok programot írni.
1. A mintakódokat bemásolom és ellenőrzöm, hogy jó-e.
2. Ha egyszer beírtam egy vezérlési struktúrát, akkor azt másolom át és módosítom.
3. Van, hogy gépelés közben elfejejtem, hogy mit akartam írni, pl. lemarad a páros jelek záró tagja.
4. Kigondolom az algoritmust, utána írom a programkódot.
5. Miközben mondom/kigondolom az algoritmust, tudom gépelni a kódot.

Statikus tömb

0. Nem tanultam még a tömbök használatát.
1. Tudok tömböt definiálni, inicializálni, elemek értékét módosítani.
2. Feladatmegoldás során a tömb elemeit egy iterátorral (indexszel) egymás után érem el.
3. Egy tömb tetszőleges elemét el tudom érni, akár véletlenszerűen is. (Pl. minden 10. elem kiválasztása, 2 db véletlen elem kiválasztása.)
4. A tömb elemeit indirekt szabályok alkalmazásával közvetlenül el tudom érni. (Pl. Eratosztenészi szitával osztók számának meghatározása.)
5. Más adatstruktúrákat is tudok tömbben tárolni, megfelelő indexelő függvényekkel bejárni. Pl. 2D tömb, bináris fa, kupac.

Debug

0. Nem tudom, mit jelent a "debugolás".
1. Debugolással nehéz a hibák megtalálása.
2. A debug hibajelzései, lépésenkénti futtatás segít a program működésének megértésében.
3. A hibák megtalálása könnyebb Debug módban, mintha át kellene olvasnom.
4. A programkód írása során a szintaktikát és szemantikát is a fejlesztőkörnyezet adta eszközzel ellenőrzöm.
5. A kódírás része a kód mentése, ellenőrzése. Akkor is gyakran végzem, ha nem figyelek rá.

ZH felkészülés

0. Nem mértem fel a tudásomat.
1. Sokkal kevesebbet tudok, mint gondoltam.
2. A haladási naplóban jellemzően többre értékeltem tudásomat, mint amit a ZH-ban sikerült teljesíteni.
3. A haladási naplóban néhány tudáselemet többre becsültem, mint amennyit be tudtam bizonyítani a ZH-n.
4. A ZH eredményeim a haladási naplóban jelzett szintet igazolják.
5. A ZH feladatok megoldása jobban sikerült, mint ahogy a haladási naplóban feltételeztem.

Logikai kifejezések

0. Nem kellett logikai kifejezésekkel dolgoznom.
1. Ismerek legalább 4 logikai műveletet, az ezekkel felírt kifejezések eredményét fel tudom írni.
2. Feladatban megfogalmazott feltételeket meg tudok fogalmazni logikai kifejezésekkel.
3. Feltételek megfogalmazásakor pontosan írom le a beszélt nyelvben elnagyolt logikai kapcsolatokat (de, is-is, sem-sem, és/vagy).
4. Ismerem és használom a logikai műveletekre vonatkozó azonosságokat; felhasználom a rövidzár kiértékelést hibakezelésre.
5. Összetett logikai kifejezést meg tudok fogalmazni azonos értelmű másik alakban. Pl. egy összetett kifejezés negáltját részkifejezések negáltjával; implikációt az alapműveletekkel.

Bitműveletek

0. Nem tudok bitekkel műveletet végezni.
1. Ismerem a számok, adatok bit-szintű implementációját (karakterek, egészek, kettes komplemens)
2. Az aritmetikai műveletek (összeadás, szorzás) biteken történő megvalósítását le tudom írni logikai műveletekkel
3. Adatok adott bitmintának megfelelését bitműveletekkel ellenőrzöm, bitspecifikus módosításhoz "mágikus számok" helyett bitműveleteket használok
4. Logikai adattömb (bool oszto[40]) helyett tudom a logikai értékeket bájtokba csoportosítva 1 biten tárolni, kezelni.
5. A bitműveleteket felhasználom digitális eszközök adatbuszon történő vezérléséhez (bitműveletekkel kapcsolatos ismereteimet más területen fel tudom használni.)

Struct

0. Nem foglalkoztam struccokkal
1. A struct számomra valami olyan, mint a tömb, csak bonyolultabb megadni.
2. Tudok struct-ot és ez alapján összetett adattípust definiálni, ilyen típusú változónak értéket adni.
3. Tudok struktúrát használni (létrehozni, módosítani, átadni, törölni)
4. Nem okoz problémát a tömböt tartalmazó struktúra vagy a struktúrák tömbje. Ezek tetszőleges kombinációját is átlátom, tudom használni.
5. A struct helyett inkább class, OOP...

Függvények

0. Nem volt dolgom függvényekkel
1. A függvény olyan reláció, amelyben az értelmezési tartomány minden eleméhez hozzárendeljük az értékkészlet pontosan egy elemét.
2. A függvény egy "gép", ami a bemenetén beadott argumentumokból előállítja a függvényértéket.
3. A függvény programegység, amely a megadott argumentumokat felhasználva a programban változásokat eredményezhet vagy a programnak visszaad egy értéket, adatot.
4. Programírás során részfeladatokban gondolkozom, rögtön függvényeket írok, nem csak utólag bontom szét a programom.
5. Programom tervezésekor adattípusokra mint objektumokra gondolok, a függvények ezen objektumok működését írják le.

Pointerek

0. Nem használtam még pointereket.
1. Megtanultam, hogy néhány feladattípusnál hogyan kell használnom a "*" és "&" karaktereket.
2. Tudom, hogy egyes esetekben a függvénynek címet kell átadni, amelyeket a függvényen belül dereferálni kell.
3. Értem a pointer és adattípus kapcsolatát, tudom, hogy pl. x, *x, y és &y hogyan "helyettesíthetik" egymást.
4. Tömböket, illetve pointereket át tudok adni függvénynek között, könnyedén alkalmazom a címképzést, dereferálást.
5. Többszörösen összetett adatszerkezeteket (pl. többdimenziós tömböt) is tudok kezelni.

Rekurzió

0. Nem tudom, mi az a rekurzió.
1. Felismerem a rekurziót, ha ilyen kódot látok.
2. Értem, hogyan és miért működik, pl. fel tudnám írni, a rekurzív faktoriális hogyan értékelődik ki.
3. Rekurzióval megoldható feladatnál meg tudom határozni a báziskritériumot és az egyszerűsítési lépéseket.
4. Észreveszem, ha rekurzióval megoldható problémával állok szemben.
5. Tudom, mi a jobbrekurzió és mi a dinamikus programozás, tudok ilyen kódot írni.

Memóriakezelés

0. Tudom, hogy az adatok a memóriában helyet foglalnak.
1. Tudok futási időben adatok számára megfelelő méretű memóriaterületet lefoglalni és felszabadítani.
2. Tudom, hogy egy memória területet pointerrel lehet "megfogni". A fel nem szabadított, de "elengedett" memória használhatatlan lesz.
3. Tudom, hogy a lefoglalt memória "ingatlan", a pointer átirányítása a mutatott adatot nem mozgatja.
4. Tudom, hogy a pointer is adat, pointereknek is lehet dinamikusan memóriát foglalni. Pl. tudnék kétdimenziós dinamikus tömböt csinálni.
5. Az indirekciók (*-ok) számának növekedése nem okoz nehézséget az adatstruktúrák létrehozásában és használatában.

Lista

0. A listáról a "todo" jut eszembe.
1. Tudom, mit jelent a lista, mint adatszerkezet.
2. Előadásanyag alapján egy adott feladathoz meg tudom írni az alapvető listaműveleteket, pl. létrehozás, beszúrások, törlés, keresés.
3. Egy adott feladathoz fejből is meg tudom írni az alapvető listaműveleteket.
4. Egyedi igényeknek megfelelően is tudom módosítani a listát, pl. több lista összefűzése, lista megfordítása, körbezárása.
5. A listákhoz hasonló tetszőleges adatstruktúrákat is meg tudok valósítani és tudom használni (pl. verem, kétirányú lista, listák listája).

Bináris fák

0. Az almafákról többet tudok.
1. Tudok példát mondani adatok bináris fa típusú kapcsolatára és le tudom rajzolni.
2. Binfa struktúrából felépített konkrét adathalmaz bármely két csúcsa között fel tudom írni pointerekkel az átmenetet.
3. Tudok legalább egy módszert a gyökerével megadott Binfa bejárására, abban elem megkeresésére, elem hozzáfűzésére.
4. Többféle Binfa bejárási módot ismerek, ezeket adatok rendezett tárolásához, gyors kereséséhez célszerűen tudom használni.
5. Nem okozna gondot összetettebb bináris fás feladat sem (pl. csomópont törlése, fák listájának építése stb.)

Program

0. Nem tudok működő programot írni.
1. A programot a main()-en belülre írom.
2. A programom elején függvények, eljárások vannak, amelyeket meghívok a main()-ben.
3. A programom elején függvény és eljárás deklarációk vannak, amelyeket a main() után definiálok.
4. A programom elején néhány saját fájlt is include-olok, mert az egyes (jellemzően egymástól független) programrészekre külön .c és .h fájlt írok.
5. A programom elején néhány saját fájlt is include-olok és ezek megfelelő együttműködését előfeldolgozó direktívákkal szabályozom.

Állapotgép

0. Állapot javító gép. Vagy kávé. Vagy tea.
1. Állapotgép olyan gép (program), ami a múltbeli események hatására létrejövő aktuális állapottól és az őt ért hatástól függően meghatározott másik állapotot vesz fel.
2. Amikor egy program megírása sok if()-et sejtet, érdemes felvázolni (modellezni) a különböző eseteket.
3. A program futása közben előforduló esetek számbavételéhez modelleket használok. Egy ilyen modell az állapotátmenetek táblázata. Ez a leírás néha segít.
4. Az állapotokat és átmeneteket leíró modellből szinte automatikusan generálom a kódot: definiálom az állapotokat és megírom az egyes átmeneteket.
5. Az állapotokat és átmeneteket leíró modell alkalmas a program optimalizálására (pl. esetek összevonására), ezt a kódolásnál kihasználom.

Függvénypointerek

0. Azt hiszem, erre nem lesz szükségem.
1. Ez kell ahhoz, hogy ne kelljen külön kódot írni a sin() és cos() kirajzolásához.
2. Tudom, hogy hol van jó minta a használatához.
3. Tudom, hogy mikor érdemes függvény pointert használni a kódolás egyszerűsítésére.
4. Menü kiírásához (például) már tervezéskor függvény pointert használok.
5. Feladatok megoldásához esetenként generikus algoritmusokat használok.