06. TANANYAG · FORRÁSKÓD
Switch – pontozás
06_Switch_kommentelt.csAnimáció megnyitása →
namespace Pontozas // A namespace (névtér) összefogja és elkülöníti az ide tartozó kódelemeket; ennek a névtérnek a neve Pontozas.
{ // A nyitó kapcsos zárójel jelzi, hogy itt kezdődik a Pontozas névtérhez tartozó kódblokk.
internal class Program // Az internal azt jelenti, hogy ez az osztály ezen az assemblyn belül érhető el; a class egy Program nevű osztályt definiál.
{ // Itt kezdődik a Program osztály törzse.
static void Main(string[] args) // A Main a program belépési pontja; static: példány nélkül futtatható, void: nem ad vissza értéket, string[] args: parancssori argumentumok tömbje.
{ // Itt kezdődik a Main metódus törzse.
// 1. PONTSZÁM BEKÉRÉSE ÉS SZÁZALÉK KISZÁMÍTÁSA.
const double MAX_PONT = 200.0; // Konstanst hozunk létre: a MAX_PONT értékét itt adjuk meg, és később már nem változtathatjuk meg; double típusú, ezért a 200.0 valós számként szerepel.
// MAX_PONT = 200; // HIBA lenne: konstansnak a deklarálása után nem adhatunk új értéket.
Console.Write($"Dolgozat pontszáma (MAX:{MAX_PONT}): "); // String interpolációval kiírjuk a maximális pontszámot is; a Write nem kezd új sort, ezért a felhasználó ugyanebben a sorban írhatja be a pontszámot.
int pontszam = int.Parse(Console.ReadLine()); // A ReadLine() szöveget olvas be, az int.Parse() pedig ezt egész számmá alakítja; az eredményt a pontszam nevű int változó tárolja.
// double szazalek = Convert.ToDouble(pontszam) * 100 / MAX_PONT; // Ez is működne: a pontszam értékét kifejezetten double típusra alakítjuk.
double szazalek = pontszam * 100 / MAX_PONT; // Előbb szorzunk 100-zal (int * int, pontos egész), utána osztunk; a Convert nem szükséges, mert a MAX_PONT double, ezért az int automatikusan double-lá alakul, és valós osztás történik.
Console.WriteLine($"A dolgozat eredménye: {szazalek}%"); // Kiírjuk a kiszámított százalékot; a % jel itt egyszerű szöveg, nem matematikai művelet.
/*
* Az alkalmazott ponthatárok:
*
* 0–40% -> 1, elégtelen
* 40% felett
* 55%-ig -> 2, elégséges
* 55% felett
* 70%-ig -> 3, közepes
* 70% felett
* 85%-ig -> 4, jó
* 85% felett -> 5, jeles
*
* Azért érdemes így megfogalmazni a határokat, mert a százalék
* nem feltétlenül egész szám. Például 81 pont 200-ból 40,5%,
* ami a program feltételei szerint már 2-es.
*/
// 2. ÉRDEMJEGY MEGHATÁROZÁSA if – else if – else SZERKEZETTEL.
int jegy; // Létrehozunk egy int típusú változót az érdemjegy tárolására; itt még nem adunk neki kezdőértéket.
if (szazalek <= 40) // Először azt vizsgáljuk, hogy a százalék legfeljebb 40-e.
{ // Ez az ág akkor fut le, ha a fenti feltétel igaz.
jegy = 1; // Ha a százalék legfeljebb 40, a jegy értéke 1 lesz.
} // Itt ér véget az első if ág.
else if (szazalek <= 55) // Ezt csak akkor vizsgáljuk, ha az előző feltétel hamis volt; ezért itt már biztosan 40 fölötti értékről van szó.
{ // Ez az ág 40-nél nagyobb, de legfeljebb 55 százalék esetén fut le.
jegy = 2; // A jegy értéke 2 lesz.
} // Itt ér véget az első else if ág.
else if (szazalek <= 70) // Ide csak 55 fölötti érték juthat; azt vizsgáljuk, hogy legfeljebb 70-e.
{ // Ez az ág 55-nél nagyobb, de legfeljebb 70 százalék esetén fut le.
jegy = 3; // A jegy értéke 3 lesz.
} // Itt ér véget a második else if ág.
else if (szazalek <= 85) // Ide csak 70 fölötti érték juthat; azt vizsgáljuk, hogy legfeljebb 85-e.
{ // Ez az ág 70-nél nagyobb, de legfeljebb 85 százalék esetén fut le.
jegy = 4; // A jegy értéke 4 lesz.
} // Itt ér véget a harmadik else if ág.
else // Ha egyik korábbi feltétel sem volt igaz, akkor a százalék 85-nél nagyobb.
{ // Itt kezdődik a végső else ág.
jegy = 5; // A jegy értéke 5 lesz.
} // Itt ér véget az else ág.
// 3. UGYANAZ A FELTÉTELLÁNC RÖVIDEBB ÍRÁSMÓDDAL.
// Ha egy if vagy else if ágban csak EGYETLEN utasítás van, a kapcsos zárójelek elhagyhatók.
// Ettől a program működése nem változik, csak a leírás lesz rövidebb.
if (szazalek <= 40) jegy = 1; // Ha legfeljebb 40%, a jegy 1.
else if (szazalek <= 55) jegy = 2; // Ha az előző nem teljesült, de legfeljebb 55%, a jegy 2.
else if (szazalek <= 70) jegy = 3; // Ha 55% fölötti, de legfeljebb 70%, a jegy 3.
else if (szazalek <= 85) jegy = 4; // Ha 70% fölötti, de legfeljebb 85%, a jegy 4.
else jegy = 5; // Minden más esetben, vagyis 85% fölött a jegy 5.
// FONTOS: ez a második feltétellánc ugyanazt az értéket számolja ki újra,
// ezért a tananyagban összehasonlításként hasznos, de valódi programban
// általában csak az egyik változatot tartanánk meg.
// 4. A SZÁMJEGY SZÖVEGES ÉRTÉKELÉSRE ALAKÍTÁSA switch SEGÍTSÉGÉVEL.
string eredmeny; // Létrehozunk egy string változót, amelybe majd az érdemjegy szöveges megfelelője kerül.
switch (jegy) // A switch a jegy aktuális értékét vizsgálja, és az ahhoz illő case ágra ugrik.
{ // Itt kezdődik a switch szerkezet törzse.
case 1: eredmeny = "elégtelen"; break; // Ha jegy == 1, az eredmeny "elégtelen" lesz; a break kiléptet ebből a case ágból.
case 2: eredmeny = "elégséges"; break; // Ha jegy == 2, az eredmeny "elégséges" lesz, majd a break lezárja az ágat.
case 3: eredmeny = "közepes"; break; // Ha jegy == 3, az eredmeny "közepes" lesz.
case 4: eredmeny = "jó"; break; // Ha jegy == 4, az eredmeny "jó" lesz.
case 5: eredmeny = "jeles"; break; // Ha jegy == 5, az eredmeny "jeles" lesz.
default: eredmeny = "érvénytelen jegy"; break; // Ha egyik felsorolt érték sem egyezik, a default ág fut le; ebben a programban normál esetben nem jutunk ide.
} // Itt ér véget a switch szerkezet.
Console.WriteLine($"A dolgozat érdemjegye: {eredmeny} ({jegy})"); // String interpolációval egyszerre írjuk ki a szöveges értékelést és a számmal jelölt érdemjegyet.
} // Ez a záró kapcsos zárójel lezárja a Main metódus törzsét.
} // Ez a záró kapcsos zárójel lezárja a Program osztályt.
} // Ez az utolsó záró kapcsos zárójel lezárja a Pontozas névteret.
/*
* KONSTANSOK: const
* ----------------
*
* Változót akkor használunk, ha az érték a program futása során változhat:
*
* int pontszam = 120;
* pontszam = 150;
*
* A pontszam változó új értéket kaphat.
*
* Konstanst akkor használunk, ha egy értéket egyszer megadunk,
* és azt a program későbbi részében nem szeretnénk megváltoztatni.
*
* const double MAX_PONT = 200.0;
*
* A const kulcsszó jelzi, hogy konstansról van szó.
*
* A sor részei:
*
* const double MAX_PONT = 200.0;
* ↓ ↓ ↓ ↓ ↓
* konstans típus név értékadó érték
* operátor
*
* Ezután a következő már hibás lenne:
*
* MAX_PONT = 250;
*
* A fordító azért jelez hibát, mert egy const értékét a deklarálása után
* nem lehet módosítani.
*
* Miért jó ez?
*
* Tegyük fel, hogy a maximális pontszámot a programban tíz különböző helyen
* használjuk. Ha mindenhová egyszerűen 200-at írunk, később nehéz átállítani
* a dolgozatot 250 pontosra.
*
* Ehelyett:
*
* const double MAX_PONT = 200.0;
*
* és mindenhol a MAX_PONT nevet használjuk.
*
* Ha később változik a dolgozat maximális pontszáma, elég egyetlen helyen
* átírni a konstans értékét.
*
* A nagybetűs MAX_PONT elnevezés itt azt is jól láthatóvá teszi, hogy
* egy rögzített értékről van szó.
*/
/*
* A SZÁZALÉKSZÁMÍTÁS
* ------------------
*
* A százalék kiszámításának általános képlete:
*
* elért érték
* ----------- × 100
* teljes érték
*
* A programban:
*
* double szazalek = pontszam * 100 / MAX_PONT;
*
* Ha például:
*
* pontszam = 150
* MAX_PONT = 200
*
* akkor:
*
* 150 × 100 / 200
* = 15000 / 200
* = 75
*
* vagyis az eredmény 75%.
*
* További példák:
*
* 80 × 100 / 200 = 40%
* 110 × 100 / 200 = 55%
* 140 × 100 / 200 = 70%
* 170 × 100 / 200 = 85%
* 200 × 100 / 200 = 100%
*
* A műveleti sorrend miatt a szorzás és az osztás azonos szinten áll,
* ezért balról jobbra hajtódnak végre:
*
* pontszam * 100 / MAX_PONT
*
* először a 100-zal való szorzás, utána az osztás.
*
* Zárójellel ugyanez egyértelműbben is leírható:
*
* double szazalek = (pontszam * 100) / MAX_PONT;
*
* MIÉRT ELŐBB A SZORZÁS?
*
* Matematikailag mindegy, de a double típus kettes számrendszerben
* tárol, és például a 0,55 nem ábrázolható benne pontosan. Ezért
*
* 110 / 200.0 * 100
*
* eredménye nem pontosan 55, hanem 55,00000000000001 lenne, és
* a szazalek <= 55 feltétel hamis lenne: 110 pontra (pontosan 55%)
* a program elégséges helyett közepest adna.
*
* Ha előbb szorzunk, a pontszam * 100 két egész szorzata, tehát pontos
* (110 * 100 = 11000), és csak egyetlen osztás marad:
*
* 11000 / 200.0 = 55
*
* Ha az osztás eredménye pontosan ábrázolható (mint a ponthatárokon),
* a double pontosan azt adja, így a határokon helyes jegyet kapunk.
*/
/*
* MIÉRT NEM KELL ITT Convert.ToDouble()?
* --------------------------------------
*
* Korábban fontos volt, hogy egész számok osztásakor egész osztás történik:
*
* 5 / 2
*
* eredménye int / int esetén:
*
* 2
*
* és nem 2,5.
*
* Ebben a programban azonban:
*
* int pontszam
*
* és
*
* const double MAX_PONT
*
* szerepel az osztásban.
*
* Vagyis például 81 pontnál előbb az egész szorzás:
*
* 81 * 100 = 8100
*
* majd az osztás:
*
* 8100 / 200.0
*
* Az egyik operandus double, ezért a C# az int értéket automatikusan
* double típusúként kezeli a művelet során:
*
* 8100.0 / 200.0
*
* így az eredmény:
*
* 40,5
*
* Ezért ez:
*
* double szazalek = Convert.ToDouble(pontszam) * 100 / MAX_PONT;
*
* és ez:
*
* double szazalek = pontszam * 100 / MAX_PONT;
*
* ebben az esetben ugyanazt az eredményt adja.
*
* A Convert.ToDouble() nem hibás, csak fölösleges.
*/
/*
* AZ if – else if – else LÁNC MŰKÖDÉSE
* ------------------------------------
*
* A feltételeket a program FELÜLRŐL LEFELÉ vizsgálja.
*
* if (szazalek <= 40)
* jegy = 1;
* else if (szazalek <= 55)
* jegy = 2;
* else if (szazalek <= 70)
* jegy = 3;
* else if (szazalek <= 85)
* jegy = 4;
* else
* jegy = 5;
*
* Amint talál egy igaz feltételt, végrehajtja annak az ágát,
* és a további else if ágakat már nem vizsgálja.
*
* Példa: szazalek = 67
*
* 67 <= 40 -> false
* 67 <= 55 -> false
* 67 <= 70 -> true
*
* ezért:
*
* jegy = 3;
*
* A 67 <= 85 feltételt a program már nem vizsgálja meg.
*
* Ez nagyon fontos, mert 67 természetesen 85-nél is kisebb,
* de az else if láncban az ELSŐ igaz ág nyer.
*/
/*
* MIÉRT ELÉG CSAK A FELSŐ HATÁRT VIZSGÁLNI?
* -----------------------------------------
*
* Első látásra ezt is írhatnánk:
*
* if (szazalek > 40 && szazalek <= 55)
* {
* jegy = 2;
* }
*
* Az else if láncban azonban erre nincs szükség.
*
* Nézzük:
*
* if (szazalek <= 40)
* {
* jegy = 1;
* }
* else if (szazalek <= 55)
* {
* jegy = 2;
* }
*
* A második feltételig csak akkor jut el a program,
* ha az első HAMIS volt.
*
* Az első:
*
* szazalek <= 40
*
* hamis volta azt jelenti:
*
* szazalek > 40
*
* Tehát amikor a második feltételt vizsgáljuk,
* már eleve tudjuk, hogy az érték 40 fölött van.
*
* Emiatt:
*
* else if (szazalek <= 55)
*
* valójában ebben a helyzetben ezt jelenti:
*
* 40 < szazalek <= 55
*
* Ugyanez igaz a további ágakra is.
*/
/*
* A FELTÉTELEK SORRENDJE FONTOS
* -----------------------------
*
* A jelenlegi feltételek növekvő sorrendben követik egymást:
*
* <= 40
* <= 55
* <= 70
* <= 85
* egyébként
*
* Ha rossz sorrendben írnánk őket, hibás eredmény születhetne.
*
* Például EZ HIBÁS:
*
* if (szazalek <= 85)
* jegy = 4;
* else if (szazalek <= 70)
* jegy = 3;
*
* Ha a százalék 60, akkor:
*
* 60 <= 85 -> true
*
* ezért rögtön 4-est kapna, és a <= 70 feltételig el sem jutna.
*
* Az ilyen egymásba ágyazott határoknál tehát a szűkebb,
* kisebb felső határtól haladunk a nagyobb felé.
*/
/*
* KAPCSOS ZÁRÓJEL NÉLKÜLI if
* --------------------------
*
* A hosszabb forma:
*
* if (szazalek <= 40)
* {
* jegy = 1;
* }
*
* Rövidíthető:
*
* if (szazalek <= 40) jegy = 1;
*
* Ez csak akkor lehetséges biztonságosan, ha az adott ághoz
* pontosan EGY utasítás tartozik.
*
* Például:
*
* if (szazalek <= 40)
* jegy = 1;
*
* itt az if csak a következő egy utasítást vezérli.
*
* Veszélyes példa:
*
* if (szazalek <= 40)
* jegy = 1;
* Console.WriteLine("Elégtelen.");
*
* A behúzás félrevezető lehet: a Console.WriteLine már NEM tartozik az if-hez,
* ezért mindig lefutna.
*
* Ezért hosszabb vagy később bővíthető kódnál a kapcsos zárójelek
* használata sokszor áttekinthetőbb és biztonságosabb.
*/
/*
* switch – VÁLASZTÁS EGY ÉRTÉK ALAPJÁN
* ------------------------------------
*
* A switch akkor kényelmes, ha egy kifejezés konkrét értékeihez
* különböző műveleteket szeretnénk rendelni.
*
* A programban:
*
* switch (jegy)
* {
* case 1: eredmeny = "elégtelen"; break;
* case 2: eredmeny = "elégséges"; break;
* case 3: eredmeny = "közepes"; break;
* case 4: eredmeny = "jó"; break;
* case 5: eredmeny = "jeles"; break;
* default: eredmeny = "érvénytelen jegy"; break;
* }
*
* A switch után zárójelben az a kifejezés áll, amelynek az értékét
* vizsgálni szeretnénk:
*
* switch (jegy)
*
* A case jelentése nagyjából:
*
* "abban az esetben, ha az érték ennyi"
*
* Például:
*
* case 3:
*
* ebben a switch-ben azt jelenti:
*
* ha jegy == 3
*
* akkor hajtsuk végre az ehhez a case-hez tartozó utasításokat.
*/
/*
* A break SZEREPE A switch-BEN
* ----------------------------
*
* A case ágak végén:
*
* break;
*
* szerepel.
*
* A break itt azt jelenti, hogy az adott ág végrehajtása után
* kilépünk a switch szerkezetből.
*
* Például:
*
* case 4:
* eredmeny = "jó";
* break;
*
* Ha jegy == 4:
*
* 1. az eredmeny értéke "jó" lesz;
* 2. a break miatt a switch befejeződik;
* 3. a program a switch utáni sorral folytatódik.
*
* Ebben a rövid változatban ugyanaz egy sorban szerepel:
*
* case 4: eredmeny = "jó"; break;
*
* A sortörésnek itt nincs külön programozási jelentése;
* csak az olvashatóságot befolyásolja.
*/
/*
* A default ÁG
* ------------
*
* A default akkor fut le, ha egyik case sem illeszkedik.
*
* Például:
*
* switch (jegy)
* {
* case 1: ...
* case 2: ...
* case 3: ...
* case 4: ...
* case 5: ...
* default: ...
* }
*
* Ha jegy értéke például 8 lenne, egyik case sem felelne meg,
* ezért a default ág futna le.
*
* A jelenlegi programban az if – else if – else lánc mindig
* 1 és 5 közötti értéket ad a jegy változónak.
*
* Emiatt normál programfutáskor:
*
* default: eredmeny = "érvénytelen jegy"; break;
*
* nem szükséges ahhoz, hogy az 1–5 közötti jegyek működjenek.
*
* Mégis hasznos, mert egyértelműen megmondja, mi történjen
* egy váratlan érték esetén.
*/
/*
* if VAGY switch?
* ----------------
*
* Az if általában FELTÉTELEK vizsgálatára kényelmes:
*
* if (szazalek <= 40)
*
* else if (szazalek <= 55)
*
* Itt nem azt kérdezzük, hogy a százalék pontosan egy konkrét érték-e,
* hanem tartományokat vizsgálunk.
*
* A switch ebben a programban a már kiszámított jegy KONKRÉT ÉRTÉKEIT
* kezeli:
*
* case 1
* case 2
* case 3
* case 4
* case 5
*
* Emiatt a két szerkezet itt természetesen egészíti ki egymást:
*
* százalékos tartomány
* ↓
* if – else if – else
* ↓
* jegy
* ↓
* switch
* ↓
* szöveges értékelés
*/
/*
* PÉLDA 1 – PONTHATÁROK KIPRÓBÁLÁSA
* ---------------------------------
*
* MAX_PONT = 200 esetén:
*
* pontszam = 80
* szazalek = 80 * 100 / 200.0
* = 40
*
* 40 <= 40 -> true
*
* jegy = 1
*
*
* Ha:
*
* pontszam = 81
*
* akkor:
*
* szazalek = 81 * 100 / 200.0
* = 40,5
*
* 40,5 <= 40 -> false
* 40,5 <= 55 -> true
*
* jegy = 2
*
* Ez jól mutatja, hogy a százalék double, tehát nem csak egész
* százalékértékek fordulhatnak elő.
*/
/*
* PÉLDA 2 – UGYANAZ A switch TÖBB SORBAN
* --------------------------------------
*
* A program röviden írja a case ágakat:
*
* case 5: eredmeny = "jeles"; break;
*
* Tanuláskor azonban sokszor áttekinthetőbb így:
*
* case 5:
* eredmeny = "jeles";
* break;
*
* A két változat működése teljesen azonos.
*
* Több utasítás is tartozhat egy case ághoz:
*
* case 5:
* eredmeny = "jeles";
* Console.WriteLine("Kiváló munka!");
* break;
*
* Ilyenkor jegy == 5 esetén mindkét utasítás lefut,
* majd a break lezárja az adott case ágat.
*/
/*
* PÉLDA 3 – switch EGY MÁSIK HELYZETBEN
* -------------------------------------
*
* A switch nem csak érdemjegyekhez használható.
*
* Például egy menüpont száma alapján:
*
* int menupont = 2;
*
* switch (menupont)
* {
* case 1:
* Console.WriteLine("Új játék");
* break;
*
* case 2:
* Console.WriteLine("Beállítások");
* break;
*
* case 3:
* Console.WriteLine("Kilépés");
* break;
*
* default:
* Console.WriteLine("Nincs ilyen menüpont.");
* break;
* }
*
* Mivel menupont == 2, a kiírás:
*
* Beállítások
*/
/*
* PÉLDA 4 – A SZÁZALÉK FORMÁZÁSA
* ------------------------------
*
* A jelenlegi program:
*
* Console.WriteLine($"A dolgozat eredménye: {szazalek}%");
*
* a double teljes megjelenített értékét kiírhatja.
*
* Ha pontosan két tizedesjegyet szeretnénk:
*
* Console.WriteLine($"A dolgozat eredménye: {szazalek:F2}%");
*
* Például:
*
* szazalek = 66,666666...
*
* megjelenítve:
*
* 66,67%
*
* Az F2 csak a KIÍRÁST formázza.
* A szazalek változóban tárolt eredeti double értéket nem módosítja.
*
* Ugyanezzel már találkozhattunk más valós számok kiírásánál is.
*/
/*
* PÉLDA 5 – EGYSZERŰ ELLENŐRZÉS A PONTSZÁMRA
* ------------------------------------------
*
* A jelenlegi program feltételezi, hogy a felhasználó értelmes,
* 0 és MAX_PONT közötti pontszámot ír be.
*
* Emiatt például:
*
* -10 pont
*
* negatív százalékot adna, és végül 1-est kapna,
*
* míg:
*
* 250 pont
*
* 125%-ot adna, és végül 5-öst kapna.
*
* Ha ezt később ellenőrizni szeretnénk, egy lehetséges megoldás:
*
* if (pontszam < 0 || pontszam > MAX_PONT)
* {
* Console.WriteLine("Érvénytelen pontszám.");
* }
* else
* {
* // Itt következhet a százalék és a jegy kiszámítása.
* }
*
* A || jelentése VAGY:
*
* pontszam < 0
*
* VAGY
*
* pontszam > MAX_PONT
*
* Ha legalább az egyik igaz, a pontszám érvénytelen.
*
* Ez már a program továbbfejlesztése, nem szükséges a mostani
* if / switch példa alapműködésének megértéséhez.
*/
/*
* PÉLDA 6 – MI TÖRTÉNIK HIBÁS BEVITELNÉL?
* ---------------------------------------
*
* A program ezt használja:
*
* int pontszam = int.Parse(Console.ReadLine());
*
* Ez azt feltételezi, hogy a felhasználó valóban egész számot ír be.
*
* Például:
*
* 150
*
* megfelelő.
*
* De:
*
* alma
*
* nem alakítható int típusú számmá, ezért az int.Parse hibát jelez.
*
* Ennek biztonságosabb kezelésére létezik az int.TryParse().
*
* Például:
*
* Console.Write("Pontszám: ");
* bool sikeres = int.TryParse(Console.ReadLine(), out int pont);
*
* if (sikeres)
* {
* Console.WriteLine($"A megadott pontszám: {pont}");
* }
* else
* {
* Console.WriteLine("Nem egész számot adtál meg.");
* }
*
* A TryParse részletes használata külön témaként is feldolgozható;
* itt csak azt érdemes megjegyezni, hogy felhasználói bevitel
* ellenőrzésére biztonságosabb megoldást adhat, mint a Parse.
*/
/*
* A PROGRAM LÉPÉSEI RÖVIDEN
* -------------------------
*
* 1. Rögzítjük a maximális pontszámot:
*
* const double MAX_PONT = 200.0;
*
* 2. Bekérjük az elért pontszámot:
*
* int pontszam = int.Parse(Console.ReadLine());
*
* 3. Kiszámítjuk a százalékot:
*
* double szazalek = pontszam * 100 / MAX_PONT;
*
* 4. if – else if – else segítségével meghatározzuk a jegyet:
*
* százalék -> jegy
*
* 5. switch segítségével a számból szöveges értékelést készítünk:
*
* 1 -> elégtelen
* 2 -> elégséges
* 3 -> közepes
* 4 -> jó
* 5 -> jeles
*
* 6. Kiírjuk az eredményt:
*
* A dolgozat érdemjegye: jó (4)
*
*
* A program tehát több korábban tanult elemet kapcsol össze:
*
* Console.ReadLine()
* int.Parse()
* változók és típusok
* const
* aritmetikai műveletek
* implicit típuskonverzió
* összehasonlítás
* if – else if – else
* switch – case – default
* break
* string interpoláció
*
* Ez már egy jó példa arra, hogyan áll össze több egyszerű
* nyelvi elem egy teljes, használható konzolos programmá.
*/
namespace Pontozas
{
internal class Program
{
static void Main(string[] args)
{
const double MAX_PONT = 200.0;
Console.Write($"Dolgozat pontszáma (MAX:{MAX_PONT}): ");
int pontszam = int.Parse(Console.ReadLine());
double szazalek = pontszam * 100 / MAX_PONT;
Console.WriteLine($"A dolgozat eredménye: {szazalek}%");
int jegy;
if (szazalek <= 40)
{
jegy = 1;
}
else if (szazalek <= 55)
{
jegy = 2;
}
else if (szazalek <= 70)
{
jegy = 3;
}
else if (szazalek <= 85)
{
jegy = 4;
}
else
{
jegy = 5;
}
if (szazalek <= 40) jegy = 1;
else if (szazalek <= 55) jegy = 2;
else if (szazalek <= 70) jegy = 3;
else if (szazalek <= 85) jegy = 4;
else jegy = 5;
string eredmeny;
switch (jegy)
{
case 1: eredmeny = "elégtelen"; break;
case 2: eredmeny = "elégséges"; break;
case 3: eredmeny = "közepes"; break;
case 4: eredmeny = "jó"; break;
case 5: eredmeny = "jeles"; break;
default: eredmeny = "érvénytelen jegy"; break;
}
Console.WriteLine($"A dolgozat érdemjegye: {eredmeny} ({jegy})");
}
}
}