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

2017.07.26.

Követelmények a Programozás alapjai I. tárgyban. Osztályzás, pontozás, néhány szó a halálfejes 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 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.
  • Röp-ZH-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.
  • Nagy HF a laboron. Ennek leadási határideje a 13. hét vége.

A jegy kiszámítsa:

Pontszám = NZH1 + NZH2 + max(KZH1, KZH2) + max(KZH3, KZH4) + max(KZH5, KZH6) (+ EXTRA)
PontJegy
0–511
52–662
67–813
82–964
97–5

Extra pontokat lehet szerezni a félév közben beadott és elfogadott szorgalmi feladatokkal, továbbá az időben elkészített nagy HF részfeladatokkal. A négy részfeladatra (NHF1 – NHF4) rendre 1, 1, 1, 2 plusz pontot lehet kapni, de csak akkor, ha a végleges feladatot nem kellett pótolni (NHF5). A szorgalmi feladatok pontjai csak 80 pont fölött számítanak. A könnyű, közepes, nehéz szorgalmik rendre 0,5; 1 és 2 pontot érnek.

A végleges pontszám a szorgalmi 0,5 pontok miatt lehet, hogy nem egész szám. Ha így adódik, a normál kerekítés szabályai szerint 0,5-től felfelé kerekítés törénik.

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

  • A jelenlétek és a röp-zh-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éntek 12:00-ig.
  • 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. (Az, amelyik a legrosszabbul sikerült.) 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 közül is az egyik pótolható: a rosszabbul sikerült, illetve egyforma pontszám esetén a második. Ez a fentihez hasonlóan jelentkezéshez kötött, és ezen is lehet rontani. Pót-pót nagy ZH már nincs.

3. 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 konzultációk keretében 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 35 pontot (5×7).

A fent említett nagy és kis zárthelyik, illetve szorgalmi és nagy házi feladat pontszámok ugyanolyan módon történő számítása 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 NZH-k minimum pontszáma ezek nélkül is meg kell legyen).

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

4. 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!

5. 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. Ezeken egy A/5-ös lapon kell megoldani egy egyszerű feladatot. A feladatgyűjtemény rengeteg régi kis ZH feladatot tartalmaz, ott látható, hogy néz ki egy ilyen. A nagy ZH-k három-négy nagyfeladatból állnak (4×10=40 vagy 2×10+1×20=40 pont). Jegy erre sem jár, csak pontszám. A honlapon régebbi feladatsorok is elérhetőek. A nagy ZH-kon használható a két oldalas C puska. Ezt egy A4-es lap két oldalára kell kinyomtatni.

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 alapvetően a programok működőképességét ellenőrizzük, de ez nem jelenti azt, hogy bármilyen működő megoldás maximum pontot ér. Az ésszerűtlen, durván hatékonytalan megoldások kevesebb pontot kapnak. Pontlevonás jár az átgondolatlan, „macskakörmözött”, kipontozott, „a másik fele ugyanígy” megjegyzéssel ellátott részekért, sormintákért, lásd a halálfejes hibák listáját.

Pontlevonás járhat a nem megfelelő nyelvi eszközök használatáért is. Ha valaki nem ismeri az indexelő vagy a nyíl operátort, esetleg meg akarja nehezíteni a javító dolgát, szándékos obfuszkációval is sok bosszúságot okozhat. Léteznek továbbá karakter, felsorolt, és egyéb típusok a nyelvben, amelyek helyes használatáért a ZH-ban pont jár. Összefoglalva: maximális pontszám olyan programkódokra jár, amelyek nem csak helyesek, hanem jók is.

*(p+3) = 17;

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

char c = 65;

felesleges zavarkeltés

p[3] = 17;

q->kov->kov = NULL;

char c = 'A';

tiszta, olvasható

A nagy ZH-kra az időben jelentkezők automatikusan +2 pontot kapnak, a javítás pontatlanságainak kompenzálására. Ezzel így elérhető a minimum ponthatár, és beleszámít a jegybe is. A +2 pont csak akkor jár, ha a betekintésen a ZH tulajdonosa nem reklamálja meg a pontszámát. A megoldást megnézni, kérdezni természetesen lehet, attól nem veszik el a pontszám! (A reklamációt alapvetően az különbözteti meg a szakmai kérdéstől, hogy pontszerzésre irányul.) Reklamáció esetén a feladatok javítását újból átnézzük, ami értelemszerűen azt is jelenti, hogy ha eredetileg a javításban voltak is pontatlanságok, akkor azok később megszűnhetnek.

6. Halálfejes hibák

Vannak olyan jellegzetes hibák, melyek egyértelműen az alapvető ismeretek hiányáról tanúskodnak. Ezzel együtt valószínűleg arról is, hogy elkövetőjük még soha nem írt számítógépen C programot. Az ilyen hibákat „halálfejes hibáknak” nevezzük. Ezekért 5 pontos levonások járnak. Ilyen hibák a következők:

  • Új nyelvi elem alkotása, pl.:
    include [stdio.h]
    
    world main {
       var $szam, $szorzat;
    
       repeat {
          scanf $szam
          $szam=$szam · $szorzat
       } until szam<>0
       printf $szorzat;
    
       return 0;
    }
    /* amíg minden elem -1 */
    while (for (i = 0; i < 10; ++i) tömb[i] == -1;)
    /* beolvasás és összegzés */
    scanf("%d", &+sum);
  • Függvénydefiníció függvényben, függvényhívás és függvénydeklaráció összekeverése, pl.
    int hanyprim(int meddig) {
    
       int prim(int szam) { // függvényben függvény nem létezik
          for (oszto = 2; oszto <= sqrt(szam); ++oszto)
             if (szam%oszto == 0)
          …
       }
    
       for (i = 2; i <= meddig; ++i)
          if (prim(int i))  // függvényhívásnál típus neve?!
             …
    }
  • Sorminták, 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];
    int i;
    
    for (i = 0; i < 10; ++i)
        scanf("%d", &sz[i]);
    
    for (i = 9; i >= 0; --i)
        printf("%d", sz[i]);

    tömb, ciklus ismeretében

  • Tömb 1-es bázisú indexelése. C-ben a tömbök 0-tól indexelődnek!
    double tomb[10];
    
    for (i = 1; i <= 10; ++i) // omg
        tomb[i] = 3.14;
  • 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 megmondja, 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

  • Definiálatlan méretű tömb létrehozása; tömbök és pointerek fogalmának, kapcsolatuknak nem ismerete, pl.
    char sztring[]; // mekkora?
    gets(sztring);
    
    char *sztring;  // hova mutat?
    gets(sztring);
  • 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:
    ListaElem *iter;
    iter = (ListaElem*) malloc(sizeof(ListaElem)); // ?!
    for (iter = lista; iter != NULL; iter = iter->kov) {
        ...;
    }
    free(iter);
  • 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 (belül: ak=ek*ln(a) stb.).