Követelmények, értékelés

2019.11.13.

Követelmények a Programozás alapjai I. tárgyban. Osztályzás, pontozás, néhány szó az elvi hibákról.

A programozás témakör oktatása az első félévben heti háromszor két órában történik: előadás és táblás gyakorlat, továbbá géptermi, laboratóriumi órák. A különféle órák számonkérései egy egységes rendszert alkotnak, együttesen határozzák meg a hét kredites tárgy végleges, félévközi jegyét.

1. A tárgy követelményei

A tárgy adatlapja: https://www.vik.bme.hu/kepzes/targyak/VIEEAA00/.

Követelmények:

  • 70% jelenlét és órai munka az előadásokon, gyakorlatokon és laborokon külön-külön. Ez maximum 4 hiányzást jelent az egyes óratípusokon. A notórius késők hiányzónak számítanak.
  • Beugrók a laboron. A laboron az elégséges felkészültséget ellenőrizzük. Az ellenőrzés formája lehet egy pár perces dolgozat az óra elején, vagy az órai feladatok egy részének megkövetelése az óra végén.
  • Kis ZH-k a gyakorlatokon. A hat darab kis ZH három párt jelent (1–2, 3–4 és 5–6). Minden párban a jobban sikerült ZH pontszáma el kell érje a 40%-ot. A rosszabbul sikerült nem számít.
  • Nagy ZH-k a ZH sávban. A két nagy ZH összegzett pontszáma kell elérje az 50%-ot. A nagy ZH-kra jelentkezni kell az adminisztrációs portálon. A két zárthelyi eredményének összege helyett a második zárthelyi pontszámának kétszeresét vesszük figyelembe, ha az magasabb.
  • Nagy HF a laboron – erről külön oldalon lehet olvasni. Leadási határideje a 12. hét vége. A házi feladatra kapott pontszám el kell érje az erre szerezhető pontszám 50%-át.

A jegy kiszámítsa:

Pontszám = max(NZH1 + NZH2, 2 × NZH2) + NZH1_IMSc
           + max(KZH1, KZH2) + max(KZH3, KZH4) + max(KZH5, KZH6)
           + NHF
           + SZORGALMI
elégtelenelégségesközepesjeles
0–6162–7980–99100–114115–

Megjegyzések:

  • Az elrontott beugrót a jelenléteknél adminisztráljuk. Ha nem sikerült, azt nem jelenti azt, hogy el kell menni, nem szabad részt venni a laboron: sőt kifejezetten azt javasoljuk, hogy ilyenkor is maradj gyakorolni az adott témakört.
  • A beugró teljesítése nem jelenti a labor teljesítését; a laborok végén az egyéni órai munkát fel kell tölteni. Ha előbb végzel, a megoldott feladatokat a laborvezetőnek személyesen be kell mutatni. Amennyiben szó nélkül lelépsz, az hiányzásnak számít, még ha fel is töltötted a megoldásokat.
  • Bár a jól sikerült második nagy ZH pontszáma duplázható, érdemes az elsőn is részt venni, és minél több pontot gyűjteni. Az első nagy ZH még csak a félév első felét kéri számon, a második ZH a teljes félév anyagát felöleli, ezáltal jóval nehezebb is.
  • A nagy ZH-kon vannak IMSc feladatok, de ezek pontszáma csak akkor számít, ha az alap feladatok legalább 75%-osak lettek.
  • A nagy házi feladat részfeladatainak időben történő leadása beleszámít annak pontozásába. Határidők lekésése esetén ezek a pontok véglegesen elvesznek.
  • Extra pontokat lehet szerezni a félév közben beadott és elfogadott szorgalmi feladatokkal. Ezek pontjai csak 80 alap pont fölött számítanak.

2. Pótlási lehetőségek

  • A jelenlétek és a beugrók nem pótolhatóak. A megengedett hiányzás / bukási lehetőség magában foglalja a pótlást.
  • A nagy HF különeljárási díj ellenében leadható a 14. héten is, péntekig (pontosan az ehhez kiírt feladat határidejéig). A részfeladatok nem pótolhatóak, a késés a TVSz szerint a pontok 20%-ának elvesztését jelenti. Hiányuk esetén a teljes házi még lehet elfogadott, ha teljesíti a követelményeket.
  • A kis ZH-k pótlása: a pótlási héten a három pár közül legfeljebb az egyik pótolható, különeljárási díj ellenében. (Amelyik a legrosszabbul sikerült, vagy a későbbi.) A pótlás jelentkezéshez kötött, a félév végén, alkalmas időpontban látszik a jelentkezési lehetőség itt, a portálon. Rontani is lehet; aki a pótláson beül a terembe, az ott elért eredménye felülírja az addigit.
  • A nagy ZH-k egybekötötten pótolhatóak vagy javíthatóak: a pótlási héten írt pót ZH pontszáma felülírja az addig megírt nagy ZH-k pontszámát, és így értelemszerűen duplázva számít. A feladatsor a teljes félév tananyagát lefedi. A pót ZH megírása jelentkezéshez kötött. Aki a pótláson beül a terembe, az ott elért eredménye felülírja az addigit. Pót-pót nagy ZH már nincs.

Megjegyzések:

  • A különeljárási díjakat a NEPTUN-ban írják ki központilag a KTH-ból, de csak jóval a félév után, általában január végén.
  • A pótlásként leadott nagy házi feladatot is be kell mutatni a laborvezetőnek, ha az addigi bemutatások során nem volt értékelhető állapotban. Ennek legvégső határideje a pótlási hét keddje. Az időpontot a laborvezető határozza meg.

3. Nulladik ZH

A félév legelején lehetőség van egy ún. nulladik, szintfelmérő zárthelyit írni. Ennek témája a félév teljes tananyaga. (Minta feladatsor elérhető a linkre kattintva.) Elég jó szintű teljesítésével mentességet lehet szerezni a jelenlét követelmények és a kis zárthelyik alól (2018-ban 26 pontnál húztuk meg a határt). Sikeres teljesítés esetén az alábbi eredményeket írjuk jóvá:

  • Gyakorlat jelenlét a teljes félévre.
  • Labor jelenlét és beugró a teljes félévre.
  • Kis ZH-k pontszámai arányosan, kerekítve (pl. 35/40 pont esetén 35/40×10 = 8.75 → 9 pontosnak tekintjük a kis ZH-kat).

A többi tárgykövetelményt (a két nagy zárthelyi, nagy házi feladat) ilyenkor is teljesíteni kell.

A nulladik zárthelyire jelentkezéshez el kell készíteni egy előfeladatot, amelyik a portálra belépés után látszik. Sikeres teljesítés esetén ugyanott lehet jelentkezni a ZH-ra. A ZH megírása után a megkapott kedvezményt el lehet fogadni vagy el is lehet utasítani. Az elfogadás a félévre nézve végleges. Mindezek határidejei órarendfüggőek, és a portálra bejelentkezve látszanak.

A nulladik ZH egyszeri kedvezmény; az előfeladatot, a jelentkezést és a ZH megírását pótolni nem lehet.

4. IMSc képzés, IMSc ZH

Tematika

Az IMSc-s hallgatók számára külön gyakorlati és labor csoportokat indítunk. (Az előadás a teljes évfolyam számára közös.) Ezekben a csoportokban ugyanazon tananyag és tematika mellett mélyebb, összetettebb feladatok gyakoroltatják ugyanazokat a témaköröket.

Az érdeklődők számára a tárgyon tanultak alkalmazását bemutató, illetve a tárgy tananyagán túlmutató szakmai írásokat teszünk közzé a tárgy honlapján. Ezek egyéni elmélyülésre adnak lehetőséget. Feldolgozásukhoz kérés esetén segítséget nyújtunk.

A számonkéréseken alkalmazott pontozás és jegyszámítás mindenkinél egységes. Az IMSc pontok megszerzése a programban nem résztvevő hallgatók számára is biztosított, azonban a tárgy kreditjének megszerzéséhez kötött.

Pontozás

A jeles alsó ponthatára feletti összes többlet pontszámot IMSc pontszámnak számolunk, a tárgy kreditértékének megfelelően összesen legfeljebb 5×7 = 35 pontot.

A fent említett pontok mellett 2×10 pontot lehet szerezni a nagy zárthelyiken választható kiegészítő feladatokkal is. A kiegészítő feladatot tartalmazó ZH-ra előzetesen jelentkezni kell. A kiegészítő feladatot csak az alap feladatok 75%-os teljesítése mellett pontozzuk, és az itt megszerzett pontok az aláírás megszerzésére nem használhatóak fel (tehát a ZH-k minimum pontszáma ezek nélkül is meg kell legyen). Az IMSc ZH-ra jelentkezést előzetesen megszerzett pontszámokhoz is köthetjük.

Az IMSc ZH-n megszerzett plusz pontok az összes többi ponthoz (KZH + NZH + NHF + szorgalmi) hozzáadódnak (+ IMSc), a jegyet is javíthatják.

5. Konzultációk

Rendszeresen tartunk személyes konzultációkat, ahol mindenkinek igyekszünk segíteni a programozási és tanulási problémáiban. Ezekre bárki eljöhet, a kérésünk csak az, hogy a kiírt időpontokra (ha épp vannak) jelentkezzetek az admin portálon, a jelentkezések menüpont alatt. Így tudjuk, hogy melyik alkalommal hány emberre számítsunk. Ha épp nem jelentkezik senki, akkor a konzultáció elmarad.

Kérdéseket feltenni az admin portálon az előadóknak, illetve az infoc KUKAC eet.bme.hu címen is tudtok. Természetesen mindenki fordulhat a saját gyakorlat- és laborvezetőjéhez is a programozással, házi feladatokkal kapcsolatos kérdéseivel!

6. A számonkérésekről általában

A nagy HF leadásához egy olyan programot kell elkészíteni, amely a félévben tanult ismereteket, algoritmusokat és adatszerkezeteket használva valósítja meg a kiírt feladatot. A programot forráskód formájában kell beadni, teljes dokumentációval, és be is kell mutatni a laborvezetőnek.

A kis ZH-k 15–20 percesek. A nagy ZH-k három-négy nagyfeladatból állnak. Jegy egyikre sem jár, csak pontszám. A nagy ZH-kon használható a két oldalas C puska. Ezt egy A4-es lap két oldalára kell kinyomtatni. A feladatgyűjtemény rengeteg régi kis és nagy ZH feladatot tartalmaz.

A nagy ZH-k feladatai ún. beugró feladatokkal kezdődnek. Ezt azt jelenti, hogy minden feladatnak van egy minimális, alapvető, a feladat szövegében jelölt része – egy olyan gondolat, ami nélkül az egész megoldás értelmetlen lenne. Ezt meg kell tudni elfogadhatóan oldani, különben a szóban forgó feladat többi része 0 pontosnak számít.

A számonkéréseken elsősorban a programok működőképességét értékeljük, de ez nem jelenti azt, hogy bármilyen működő megoldás maximum pontot ér. Legjobb értékelést csak azok a programkódok kapják, amelyek nem csak helyesek, hanem azon felül jók is.

A feladatokra egy megoldást kell adni. Ha több megoldást kapunk ugyanarra a feladatra, akkor találomra az egyiket javítjuk, vagy levonjuk a pontot az összesben lévő hibákért. A kommentek nem számítanak a feladat megoldásának, ugyanakkor részei a kódnak; a bennük lévő szakmai tévedésekért vagy inkonzisztenciáért pontlevonás jár. Ugyanez a helyzet a többlet kóddal: a feladat megoldásához hozzátartozik az is, hogy érteni kell, mit vár a feladat, és mit nem.

A javítókulcs célja a helyes megoldások értékelése. Pontlevonás jár az olyan hibákért is, amikről a javítókulcs nem rendelkezik külön. Például nem jár külön pont azért, hogy valaki tudja-e a printf()-et használni, viszont pontlevonás jár érte, ha nem; elvégre is az első hét tananyagáról van szó. A megfelelő nyelvi eszközök használatát is értékeljük. Ha valaki nem ismeri az indexelő vagy a nyíl operátort, a karakter, a felsorolt vagy a logikai típust, pontot veszít. Az észszerűtlen, durván hatékonytalan megoldások is kevesebb pontot kapnak.

*(p+3) = 17;

(*(*q).kov).kov = NULL;

int betu = 65;

felesleges zavarkeltés és pontlevonás

p[3] = 17;

q->kov->kov = NULL;

char betu = 'A';

tiszta, olvasható

Különös tekintettel vagyunk a függvények mellékhatásaira, paramétereikkel kapcsolatos előfeltételezésekre. A függvények lényege, hogy többször felhasználhatóak, ezért akkor is helyesen kell tudniuk működni, ha többször meghívják őket. „A feladatban csak egyszer kellett meghívni” – ez nem lehet hivatkozási alap reklamációnál. Ahogy az sem, ha a függvényből bizonyos dolgok kifelejtődtek, esetleg máshol történtek meg (pl. ha a függvény dolga lenne egy tömböt nullával feltölteni a használat előtt). Ha a feladat külön megköti, melyik megírandó függvénynek mi a dolga, akkor hiba máshol elvégezni azokat a teendőket.

A fentieken kívül pontlevonás jár az alapvető sztringkezelő függvények nem ismeretéért, újraimplementálásáért – kivétel természetesen, ha kifejezetten ez volt a feladat. A következőeket tekintjük alapvetőnek: strlen, strcpy, strcmp, printf %s és scanf %s.

A szorgalmi feladatok javítása a ZH-kénál szigorúbb. Itt visszautasítás oka lehet a helytelen kódolási stílus, még amúgy jól működő program esetén is. A megoldást többször is le lehet adni, de a jelzett hibákat mindenképp javítani kell.

7. Megtekintés, reklamáció

A nagy ZH-k megtekintését is központilag szervezzük. Itt lehetősége van mindenkinek megnézni, hogy milyen hibái voltak. A megtekintésekre a nagy létszám miatt a portálon jelentkezni kell. Reklamálni helyben nem lehet; az esetleges reklamációt másnap reggelig kell feltölteni a portálra, mint bármelyik beadandót.

A reklamáció célja a javító hibájának korrigálása. Vagyis akkor lehet reklamálni, ha nincs megadva olyan pont, amit a javítási útmutató szerint meg kellett volna adni. A beküldött reklamáció a tananyagot nézve ellenőrizhető, a ZH-n megírt program kipróbálható és így tovább. Nem érdemes a „bepróbálkozás” kedvéért beadni reklamációt: ha a javítás helyes, akkor a reklamáció kell szakmailag hibás legyen, és az ilyet negatívan értékeljük.

A reklamáció formai követelményei az alábbiak:

  • A reklamáció tartalmazza a hibásan pontozott rész helyét, tartalmát (kép a megoldásról beszúrva, releváns rész kivágva), az értékelést és a reklamáció szakmai indoklását.
  • Amennyiben a szöveg formai hibás (lásd az előző pontot), vagy nem a lapra írt megoldásra vonatkozik, esetleg szakmához nem tartozó érvelést tartalmaz, a reklamáció egésze automatikusan eredménytelen.
  • Ha bármelyik pont indoklása szakmai tévedést tartalmaz, vagy olyan pontot vitat, amelyik a pontozási útmutató vagy az általános pontozási irányelvek alapján nem járna, az a reklamáció egészét érvényteleníti. Csak olyan pontot érdemes reklamálni, amelyik tényleg jár: „reklamálok öt pontot, hátha összejön belőle kettő” – ezt a hozzáállást semmilyen szinten nem toleráljuk.
  • Reklamáció esetén nem csak a reklamált pontok részekre koncentrálunk, hanem esetleg újra kijavítjuk az egész feladatot vagy az egész ZH-t.

1. példa

Feladat: írj függvényt, amelyik megadja, hogy egy szám prímszám-e!

Megoldás a papíron:

void primszam(int szam) {
    for (int oszto = 2; oszto < szam; oszto += 1) {
        if (szam % oszto == 0) {
            printf("Nem prímszám.");
            return;
        }
    }
    printf("Prímszám.");
}

Reklamáció: jár a pont arra, hogy a függvény megadja, prímszám-e a kapott szám.

Értékelés: a reklamáció helytelen; olyan pontot vitat, ami valójában nem jár. A függvény visszatérési értékében kellett volna megadja a választ, true = igen, false = nem. Ez attól függetlenül is így kell legyen, hogy a feladat többi részében mit kellett csinálni. A paraméter vagy visszatérési érték helyett nem kért I/O művelet amúgy –5 pontot érő elvi hiba is. A reklamáció többi része is érvénytelen.

2. példa

Feladat: írj függvényt, amelyik megadja, hogy egy szám prímszám-e!

Megoldás a papíron:

bool primszam(int szam) {
    for (int oszto = 2; oszto < szam; oszto += 1) {
        if (szam % oszto == 0)
            return false;
        else
            return true;
    }
}

Reklamáció: jár a pont arra, hogy a függvény megvizsgálta az osztókat.

Értékelés: a reklamáció szakmai hibás. Az elágazás mindkét ágában visszatér a függvény, tehát csak a legelső osztót vizsgálja meg, a 2-t. A reklamáció többi része is érvénytelen.

3. példa

Reklamáció: csak két pont kéne; kicsapnak a koliból; negyedjére csinálom a tárgyat; nem volt nálam C puska; elkéstem a ZH-ról, ezért nem volt időm befejezni; csak ez a tárgy kell a szakirányhoz; nem volt fair a javító; nem úgy gondoltam, ahogy a lapra írtam; ...

Értékelés: nem szakmai indok, a reklamáció többi része is érvénytelen.

8. Elvi hibák

Vannak olyan jellegzetes hibák, melyek egyértelműen az alapvető ismeretek hiányáról tanúskodnak. Az ilyen hibákat elvi hibáknak, néha „halálfejes hibáknak” nevezzük. Ezekért a nagy ZH-kon és a kis ZH pótlásokon 5 pontos levonások járnak. Ezek a következők:

A) Sorminták, „copy paste”-ek, macskakörmözések
... amelyek helyett triviálisan ciklus, tömb, függvény lenne használható:
int a, b, c, d, …;
scanf("%d", &a);
  –||– ("%d", &b);
         –||–    c);
…
printf("%d", c);
  –||–   ("%d", b);
  –||–   ("%d", a);

sorminta

int sz[10];


for (int i = 0; i < 10; ++i)
    scanf("%d", &sz[i]);

for (int i = 9; i >= 0; --i)
    printf("%d", sz[i]);

tömb, ciklus ismeretében

Ellenpélda. Ez nem azt jelenti, hogy bármit tömbben kell tárolni, amiből egynél több van:

  • Másodfokú egyenlet együtthatói: double a, b, c rendben van – ez a matematikai jelölés is.
  • Szülők adatai:
    struct Szulok {
        char papa[100+1];
        char mama[100+1];
    };
B) Függvényparaméterek és visszatérési érték helyett I/O
A feladatkiírás által kért függvényparaméterek és visszatérési értékek helyetti I/O művelet. Pl. „írj függvényt, amely megadja, hogy egy szám páros-e”:
void paros_e(int szam) {
    if (szam % 2 == 0) printf("paros"); // ?!
}

nem ez a feladat

bool paros_e(int szam) {
    return szam % 2 == 0;
}

hanem ez

Ellenpélda. A fenti elvi hiba abban az esetben érvényes, ha a kiírás vagy beolvasás a függvény paraméterezését próbálja helyettesíteni. Például egy hibakeresési célú kiírás, esetleg hibajelzés nem ilyen:

ListaElem * lista_beolvas(void) {
    FILE *fp;
    fp = fopen("nevek.txt", "rt");
    if (fp == NULL) {
        printf("Nem lehet megnyitni a fájlt!"); // nem elvi hiba
        return NULL;
    }
}
C) Tömb és pointer fogalmának keverése
Definiálatlan méretű tömb létrehozása; tömbök és pointerek fogalmának, kapcsolatuknak nem ismerete:
char sztring[]; // mekkora?
gets(sztring);

char *sztring;  // hova mutat?
gets(sztring);

1. ellenpélda. Ez nem azt jelenti, hogy a memóriaterület nem lett felszabadítva, vagy hogy felszabadítás után megpróbáljuk elérni az adatot. A fenti kódokban kísérlet sincs a foglalásra. A sztring[]-es sor azt mutatja, hogy a ZH írója nem tudja: a tömb nem foglalódik le magától, nem nő meg magától. A char *sztring-es pedig azt, hogy nem tudja, hogy a pointer létrehozása által nem fog tömb is keletkezni.

2. ellenpélda. Nem az inicializálatlan változó az elvi hiba! A fenti char *sztring-es kód nem ezt mondja. Hibának számít az inicializálatlan változó, de közel sem akkora gond, mint a pointer működésének nem ismerete.

D) Adatszerkezetek, azok jellegzetes műveleteinek keverése

Tömböt vagy tömbre mutató pointert indexelünk, láncolt listán a next pointerekkel ugrálunk, bináris fa összes csomópontját rekurzióval érjük el.

Ha valaki egy láncolt lista elejére mutató pointert megindexel, esetleg egy bináris fát úgy próbál bejárni, hogy két ciklust ír, amelyek szerinte feldolgoznák a bal és a jobb részfát – valószínű nem érti, hogyan működnek ezek az adatszerkezetek. Ezek, és hasonló mértékű félreértések elvi hibának számítanak.

E) Pointer, mint fura lokális változó
Annak hite, hogy a pointer egy körülményes lokális változó, amely által mutatott típushoz minden esetben memóriaterületet kell foglalni. Mintha a pointer csak malloc()-kal együtt működne:
ListaElem *iter;
iter = (ListaElem*) malloc(sizeof(ListaElem)); // ?!
for (iter = lista; iter != NULL; iter = iter->kov) {
    ...;
}
free(iter);
F) Bitműveletek és lebegőpontos aritmetika

Bitműveletes feladatban pow() függvény használata. A pow() függvény double számokkal dolgozik, nem egészekkel. Emiatt szinte minden egyéb elvégzett művelet, az ilyen kódban, lebegőpontos értékekhez fog vezetni, amiken a többi ilyenkor használatos operátor (pl. |, %) már nem is értelmezett. A lebegőpontos műveletvégzés miatt pontatlan lehet az eredmény.

Ugyanígy hibásnak számítanak az ilyen feladatoknál a biteket tömbbe, sztringbe kicsomagoló, onnan visszacsomagoló megoldások. Ezek is mind a bitműveletek megkerülését célozzák.