Labori materjal

• Slaidid: Silumine
• Slaidid: Makefile ja logimine
• Täiendav näide: Korduvkasutatava koodi (teegi) loomine
• Lisalugemist: Fun with valgrind (inglise keeles)
• Testfailid valgrindi proovimiseks: https://blue.pri.ee/ttu/files/iax0584/demokood/valgrind.zip

Laboriülesanded

Selles laboris on üks ülesanne, mis on jagatud kahte ossa. Ülesannet laiendab kaks edasijõudnute ülesannet.

NB! Kuigi arendada saad oma lahendused ükskõik mis platvormil, siis üks osa tõestusest vajab Valgrind tööriista kasutamist. Valgrind töötab kontrollitult vaid Linuxil (rakendus olemas ka MacOSil) – vajadusel saad rakenduse tõestuseks üles laadida kooliarvutisse.

Lae alla andmefailid: https://blue.pri.ee/ttu/files/iax0584/andmefailid/6_make_data.zip

Arhiiv sisaldab andmefaile nii baasülesandeks kui edasijõudnute ülesandeks!

Ülesande osa 1 / 2: Andmete lugemine, töötlemine

Esimeses osas on meie eesmärgiks saada programmi andmed sisse ning demonstreerida oma oskusi Makefile’i koostamiseks ja kasutamiseks ning mälus vigade puudumiseks.

Nõuded

• Loe andmed sisendfailist
  • Andmefaili struktuur
    <õppeaine nimi> <hinnete arv> <hinded>
  • Loetud andmed salvesta struktuurimassiivi. Hinnete jaoks võid teha mõistliku pikkusega massiivi – näiteks max 20 hinnet aine kohta (lähtuvalt näitefaili struktuurist).
• Kuva ekraanil
  • Õppeaine nimi
  • Õppeaines antud hinded
  • Õppeaine keskmine hinne
• Hoia andmete lugemine, keskmise leidmine ja väljastus eraldi funktsioonides!
• Kood peab olema tükeldatud vähemalt kahte koodifaili, millest mõlemal on oma päisefail. Tükeldus peab olema mõistlik, kuid on jäetud sinu otsustada.
• Kood kompileeri programmiks kasutades Makefile’i
  • Makefile’is peab olema minimaalselt kirjeldatud retsept all , muutuja CFLAGS  ja lipud -Wall -Wextra -Wconversion -g
  • Ülejäänud Makefile’i keerukuse ja ülesehituse võid ise otsustada
•  Kaitsmisel
  • Näita projekti kompileerimist kasutades Makefile’i
  • Näita programmi väljundit läbi Valgrindi tõestamaks, et puuduvad mäluvead.

Vihje

Hinnete arv aine kohta varieerub – st iga failis olev andmerida võib olla erineva pikkusega. Seetõttu andmefaili võimalik lugeda ühe ühte fscanf()  funktsiooni väljakutsega!

Lugemine on vaja teha pesastatud tsüklitega, kus

• Välimine tsükkel loeb õppeaine nime ning hinnete arvu
• Vastavalt välimisest tsüklist saadud hinnete arvule määratakse ära sisemise tsükli korduste arv, lugemaks sisse õppeaines antud hinded. Ära unusta sisemise tsükli fscanf()  funktsiooni tagastust kontrollida!

Testimine

Näide võimalikust koodi struktuurist.

NB! Failide nimed ei ole ette määratud, tegu on lihtsalt näidisega. Samuti piisab vaid ühest andmefailist ning see ei pea olema eraldi kaustas.

NB! Järgnevas näites ei ole kajastatud valgrindi väljundit! Ära unusta testida oma programmi korrektsust valgrindiga!

Ülesande osa 2 / 2: Logimine

Selle osa raames tuleb sul lisada oma programmi logimine.

Nõuded

• Lisa oma programmi logimine
  • Üks logi rea kohta. Logi ei tohi olla kaherealine!
  • Iga logi rida algab ajatempliga. Ajatempel peab sisaldama kuupäeva (päev, kuu, aasta) ja kellaaega (tunnid, minutid, sekundid)
• Programmi järgmine käivitus ei tohi kustutada eelneva käivituse logi
• Logitavad sündmused
  • Programmi käivitamine ja sulgemine
  • Sisendfaili avamise seisund (edukas / ebaõnnestunud)
  • Faili lugemine lõpetatud. Logis kuva loetud ridade arv!
  • Faili lugemine katkestatud kuna massiivi maksimaalne piir on ületatud (maksimaalne piir kuvatakse logis).  NB! Sul on struktuuride massiiv ja struktuuri liikmena hinnete massiiv!
  • Viga aine keskmise hinde arvutamisel.
• Logi terviklikkus peab olema garanteeritud ka programmi kokkujooksu korral
  • Võimalus 1: Väljundpuhvrist on võimalik sunniga andmed faili kirjutada kasutades funktsiooni fflush()
  • Võimalus 2: Sulge logifail pärast kirjutamist – faili sulgemise järel kirjutatakse puhvris olevad andmed faili.
• Logifaili avamise ebaõnnestumisel peab programm jätkama tööd, mitte väljuma! Teavita kasutajat logimise ebaõnnestumisest.

Vihjeid

• Valmista ette logitav sõne enne logimise funktsiooni väljakutsumist! Ära koorma logimise funktsiooni üle parameetritega. Sõne ettevalmistamiseks on hea funktsioon snprintf()
• Logifunktsiooni lihtsustamiseks on soovitatav mitte failiviita ega nime sellele kaasa anda. Võimalike lahendusi:
  • Ava ja sulge fail logifunktsioonis järjest
  • See on üks võimalikest eranditest globaalmuutujale – soovi korral võid teha failiviida logifailile globaalmuutujana. (See ei ole hea lahendus, kuid aktsepteeritav – parem võimalus on kirjutatud lahti edasijõudnute ülesandena).
• Näiteks võiks logimise väljakutsumine välja näha nii:
  Logger("Program started");

Edasijõudnute ülesanne 1: Logimise teek

Selle ülesande raames lood sa endale logimise teegi. Vihje: seda saad ära kasutada kodutöö 2 juures!

Nõuded

• Lisa programmile eraldi .c ja .h fail ja tõsta sinna logimine
• Lisa 4 logimise taset – OFF, ERROR, WARNING ja INFO – need on loendi tüüpi (enum).
  • Iga logifaili rea juures on kirjeldatud selle logi tase.
  • Logi kirjutatakse faili vaid siis, kui määratud tase seda lubab. Näiteks:
    INFO taseme korral kirjutatakse kõigi tasemete logid;
    WARNING taseme korral kirjutatakse ainult WARNING ja ERROR tasemega logid;
    ERROR taseme korral kirjutatakse ainult ERROR tasemega logid;
    OFF korral logisid ei kirjutata;
• Iga kutse logi kirjutamiseks peab nüüd sisaldama selle logi olulisuse taset (ERROR, WARNING või INFO)
  Näiteks: Logger(LOG_INFO, "Program started");
• Teek peab toetama logi väljundfaili nime andmist
  Näiteks: LoggerSetOutputName("log.txt");
• Teek peab toetama programmi logitaseme sättimist
  Näiteks: LoggerSetLoggingLevel(LOG_INFO);
• Logimise seadistused tuleb hoida logimise teegi sisemiselt. Selleks on logifaili nimi ja logi tase (võid ka lisada täiendavaid). Need hoiusta logi koodifailis globaalmuutujatena.
• Logifaili seadistustel peavad olema vaikeväärtused – näiteks kui kasutaja unustab või ei soovi neid seadistada, siis programm ei läheks katki.
• Iga logi peab sisaldama kellaaega nii nagu oli kirjeldatud ülesande teises osas.

Edasijõudnute ülesanne 2: Lihtsustatud CSV failist lugemine

Selle edasijõudnute ülesande eesmärgiks on võimaldada mitmest sõnast koosnevaid õppeainete nimesid.

Nõuded

• Kasuta sisendfailina CSV versiooni sisendfailist
• Andmeväljad on üksteisest eraldatud komaga. Andmeväljad ise komasid ei sisalda.

Lahenduskäik

NB! Kasutame lihtsustatud metoodikat CSV lugemiseks. Sellega ei ole võimalik lugeda ükskõik missugust CSV faili! St kui andmeväli võib sisaldada ka komasid, siis seda metoodikat kasutada ei saa!

Kui vajad täielikku CSV tuge, kasuta kas vastavat teeki (nt libcsv) või kirjuta näiteks olekumasina-põhine töötlemine (loed tähemärk-haaval ja otsustad mida teha lähtuvalt loetud tähemärgist ja hetkeolekust olekumasinas)

---

scanf() funktsioonide perekond võimaldab lisaks andmeformaadi kirjeldamisele ka kirjeldada oodatavat sisendit ning lihtsamaid regulaaravaldisi.

Näiteks lugemaks kasutajalt kellaaega, saame kasutada formaati scanf("%d:%d", &hours, &minutes);  – sellisel juhul saab kasutaja sisestada kellaaja formaadiga 14:35 . Muutuja hours  saab väärtuseks 14 ja minutes  väärtuseks 35 . Kui aga kasutaja sisestab 14 35 , siis hours  saab ikka väärtuseks 14 , kuid kuna tühik polnud oodatud formaat, siis sealt edasi ei loeta ning minutes  jääb väärtustamata.

Lähtuvalt sellest teadmisest saame koostada faili lugemiseks formaadi fscanf(fp, "%[^,],%d", ...)  . Asenda failiviida nimi enda kasutatud viidaga ning kolme punkti asemele pane oma muutujad kuhu andmeid salvestad.

• Esimene väli loetakse tekstina kuniks komani (koma ei loeta). See salvestatakse tekstimassiivi (õppeaine nimi)
• Seejärel loetakse puhvrist välja koma (ja visatakse ära)
• Siis loetakse sisse üks täisarv (hinnete arv aines)

Sedasi saad loetud esimesed 2 välja. Edasi pead juba formaadi koostama hinnete lugemiseks (ära komasid unusta!).

Pärast seda tundi peaksid

• Teadma erinevate ehitussüsteemide kohta
• Oskama koostada lihtsat Makefile’i
  • Teadma kuidas deklareerida muutujaid ja neid kasutada
  • Teadma kuidas koostada retsepti, sh mitut retsepti ühes failis
  • Teadma mis retsepti sees käib
  • Teadma varjatud reeglitest ja oskama neid vajadusel kasutada
• Oskama kasutada Makefile’i programmi kompileerimiseks
• Oskama kasutada valgrindi programmist vigade leidmiseks ja korrektsuse kontrollimiseks
• Oskama programmi siseselt hetke kellaaega leida ning seda kujundada
• Teadma logimise põhitõdesid ja olulisust

Täiendav materjal

• Make manual
  https://www.gnu.org/software/make/manual/make.html
• What is a Makefile and how does it work?
  https://opensource.com/article/18/8/what-how-makefile
• Compiling Programs with Make
  https://web.stanford.edu/class/archive/cs/cs107/cs107.1194/resources/make
• Makefile tutor project (näidisprojektid koos Makefile’iga)
  https://github.com/clemedon/Makefile_tutor
• Makefile tutorial
  https://makefiletutorial.com
• VMWare VSphere Logging options (levels)
  https://docs.vmware.com/en/VMware-vSphere/8.0/vsphere-vcenter-configuration/GUID-0439D577-66F7-4584-AF05-5EB41A761873.html
• Logimise teegi näidis (keerukam kui meil vaja)
  https://github.com/rxi/log.c
• strftime() funktsioon
  https://www.cplusplus.com/reference/ctime/strftime/
• Valgrind dokumentatsioon
  https://valgrind.org/docs/manual/index.html
• Teegi tegemise juhend
  http://www.yolinux.com/TUTORIALS/LibraryArchives-StaticAndDynamic.html
  
• Address Sanitizer dokumentatsioon
  https://github.com/google/sanitizers/wiki/AddressSanitizer

 

Labori materjal

• Slaidid: funktsioonid
• Täiendav funktsioonide näide: dist_converter.c

Esitamisele kuuluvad ülesanded

Esitamisele kuuluvad 2 ülesannet. Lisaks on 1 edasijõudnute ülesanne, mis on teise tunnitöö laienduseks.

Esimeses ülesandes on sinu rolliks olemasolevas programmis vaid funktsioonide sisud kirjutada. Selle programmi raames töötame vaid üksikute muutujatega.

Teises ülesandes tuleb kirjutada kogu programm juhendi põhjal

Ülesanne 1: Elektri hinna kalkulaator

Antud ülesandes on sinu eest juba kogu programmi loogika valmis tehtud. St kogu main()  funktsiooni sisu on juba valmis ja seda muuta ei ole põhjust.

Tegemata on jäetud aga enda loodavate (user-defined) funktsioonide sisud ning need on vastavalt asendatud kõik tagastama 0 väärtust (selleks, et programm kompileeruks). Sinu ülesandeks täita kõigi funktsioonide deklaratiivne osa (keha) vastavalt funktsioonile eelnevale kommentaarile.

Lae alla ülesande aluskood siit: 6_1_electricity_basecode.c

Nõuded

• Ülesande lahendamist alusta baaskoodiga tutvumisest. Sinu lahendus peab olema ehitatud ette antud baaskoodile.
• Sinu ülesandeks on kirjutada funktsioonide kehad seitsmele funktsioonile. Funktsiooni eesmärk on kirjeldatud selle ees kommentaarina.
• main()  funktsiooni sisu ja koodi struktuuri muuta ei tohi. Soovitav on vältida ka funktsioonide ja muutujate ümbernimetamist.

Vihjeid ja soovitusi

• Alusta tutvumist koodi ülesehitusest. Vaata kus on makrod, kus prototüübid, kus main() ja kus funktsioonid. Vaata kuidas main() funktsioonist teisi funktsioone välja kutsutakse, mis kaasa antakse jne. Ära muuda midagi alguses!
• Üldine pilt selge, hakka järjest funktsioonide sisusid täitma.  Lahenda 1 funktsioon korraga, kompileeri ja testi enne kui järgmise juurde lähed!
• Sisestuse funktsioonides on soovitatav struktuur do while tsükkel, mille sees on if lause veateate väljastamiseks.
• Kõik ülejäänud funktsioonid on lahendatavad ühe reaga, asendades olemasoleva return 0  asemel õige valemi
• Ettevaatust ühikutega. Erinevates kohtades on kord kasutusel vatt-tunnid, kord kilovatt-tunnid, kord megavatt-tunnid! Juhindu funktsiooni kommentaaridest.
• VAT – value added tax tähendab käibemaksu (Eestis 20%)
• Jooksev börsihind MWh kohta (enne makse) on leitav https://dashboard.elering.ee/et
• Jooksvat börsihinda kWh kohta sentides koos maksudega näitab https://www.elektrikell.ee

Testimine

Test 1: veavaba sisend

Test 2: Vigane sisend

Ülesanne 2: massiivist tulemuste leidmine

Teise ülesande eesmärk on massiivist erinevate tulemuste leidmine vastavalt senistele teadmistele. Loodavad funktsioonid peavad olema universaalsed (ei sõltu massiivi pikkusest). Need on muuhulgas ka esimesed sageli kasutatavad funktsioonid sinu varasalve mida saad tulevikus kiirelt kasutusse võtta!

Nõuded

• Loo programm, mis loeb kasutajalt 5 täisarvu. Arvud jäävad vahemikku -100 … 100
• Trüki loetud massiiv enesekontrolliks välja.
• Leia aritmeetiline keskmine ja kuva see kahe komakohaga
• Leia ning kuva väikseim arv massiivis
• Luba kasutajal sisestada otsitava numbri ning leiab ja kuvab kas see paikneb varasemalt sisestatud massiivis või mitte.
• Funktsioonid (sh nende parameetrid ja tagastus) peavad vastama täpselt käesoleval leheküljel antud nõuetele (ptk “Ülesande samm-sammuline lahendusjuhend”)

Kondikava

Järgnevalt on soovitus ülesande lahenduse kondikavaks.

Ülesande samm-sammuline lahendusjuhend

Ülesande loomisel on täiendavad reeglid lisaks varasemalt õpitule.

• Makrotena defineeritud konstandid mis võivad ülesandest ülesandesse erineda (nt massiivi pikkus, min ja max väärtused, maksude suurus) tuleb edastada funktsiooni parameetrina.  See ei kehti maagilistele numbritele, mis kunagi e muutu (nt elektroni mass, universaalne gaasikonstant, pi).
  
  // Näide on toodud tunnitöö 1 pealt // Maagiline arv on defineeritud makrona #define VAT_PERCENTAGE 20.0f // Funktsiooni väljakutses anname kaasa makro CalculateVat(pricePerKwh, VAT_PERCENTAGE); // Funktsioonis endas on ta juba parameeter (lokaalmuutuja) float CalculateVat(float price, float vatPcnt):

  1 2 3 4 5 6 7 8 9 10

  // Näide on toodud tunnitöö 1 pealt   // Maagiline arv on defineeritud makrona #define VAT_PERCENTAGE 20.0f   // Funktsiooni väljakutses anname kaasa makro CalculateVat(pricePerKwh, VAT_PERCENTAGE);   // Funktsioonis endas on ta juba parameeter (lokaalmuutuja) float CalculateVat(float price, float vatPcnt):

• Tulemusi leidvatel funktsioonidel ei tohi olla kõrvalmõjusid (nt aritmeetiline keskmine, vähim arv, kas arv on funktsioonis). Tulemus tuleb tagastada main funktsiooni ja seal välja trükkida.  Leitud tulemuse väljatrükk funktsioonis endas on keelatud!
• Kõrvalmõjud on lubatud ainult sisestuse ja väljastusega tegelevates funktsioonides (nt “ühe arvu sisestus” ja “massiivi väljastus”)
• Globaalmuutujaid ei kasuta! Kõik muutujad peavad olema lokaalmuutujad, andmevahetus käib parameetrite ja tagastuse abil.

Lahenda programmi samm-sammu haaval. Testi igat funktsiooni pärast selle loomist enne edasi minemist. Funktsioonid on toodud selles järjekorras nagu soovitame neid luua antud ülesande tarbeks.

Luua tuleb kõik all kirjeldatud funktsioonid. Funktsioone võib olla enam kui see tundub otstarbekas. Meeldetuletuseks – funktsioonid on lühikesed ja lihtsad, millel reeglina puuduvad kõrvalmõjud ja mis teevad vaid ühte asja (ja teevad seda hästi).

 ➡ Funktsioon: ühe täisarvu sisestus

Kirjeldus: Loeb kasutajalt ühe täisarvu, mis peab asuma ettemääratud vahemikus. Vahemik antakse funktsiooni parameetritega seda välja kutsudes. Funktsioon ei tohi enne tagastada tulemust, kui kasutaja on sisestanud sobiliku väärtuse. Ebasobiliku numbri korral küsitakse sisestust uuesti.

Parameetrid:

• Täisarv, millest väiksem ei tohi sisestus olla.
• Täisarv, millest suurem ei tohi sisestus olla.

Tagastus: Täisarv, mis jääb vahemikku min ja max.

Kasutus: Programmi raames tuleb sul kahes kohas kasutajalt sisestusi küsida. Kasuta seda funktsiooni mõlemas neist kohtadest!

 ➡ Funktsioon: massiivi täitmine

Kirjeldus: Funktsiooni abil loetakse sisse n arvu ning salvestatakse need massiivi. Funktsioonis endas ühtegi scanf()  lauset olla ei tohi! Arvu lugemiseks kutsutakse välja eelnevalt tehtud funktsioon “ühe täisarvu sisestus”, tagastatav tulemus salvestatakse massiivi. Seda tehakse korduvalt tsüklis iga liikme lugemiseks.

Parameetrid:

• Täisarvude massiiv –  täidetav massiiv.
• Täisarv – massiivi liikmete arv.

Soovi korral võid lisada funktsiooni täiendavalt 2 parameetrit min ja max (loetavate väärtuste alam- ja ülempiir)

Tagastus: puudub.

 ➡ Funktsioon: massiivi väljatrükk

Kirjeldus: Funktsiooni abil trükitakse ekraanile selles sisalduvad väärtused.

Parameetrid:

• Täisarvude massiiv – väljastatav massiiv.
• Täisarv – massiivi liikmete arv.

Tagastus: puudub.

 ➡ Funktsioon: aritmeetiline keskmine

Kirjeldus: Funktsiooni abil leitakse massiivi liikmete aritmeetiline keskmine ning tagastatakse see.

Parameetrid:

• Täisarvude massiiv – massiiv, mille väärtuste keskmist leitakse.
• Täisarv – massiivi liikmete arv.

Tagastus: reaalarv – aritmeetiline keskmine.

 ➡ Funktsioon: vähim arv

Kirjeldus: Funktsiooni abil leitakse massiivi liikmete hulgast vähim väärtus ning tagastatakse see.

Parameetrid:

• Täisarvude massiiv – massiiv, mille väärtuste hulgast vähimat leitakse.
• Täisarv – massiivi liikmete arv.

Tagastus: täisarv – väikseim väärtus massiivis.

Testimine

Test 1: vigu ei esine

Test 2: vead sisendis

Edasijõudnute ülesanne 1: Massiivist väärtuse leidmine

Selle ülesande käigus tuleb luua täiendav funktsioon, mille raames kontrollitakse kas otsitav arv on massiivis või mitte.

Ülesande raames on lubatud kasutada kodeeritud täisarvu asemel tõeväärtust (boolean), kuid teemana jõuame selle juurde alles mõne nädala pärast.

Meeldetuletuseks:

• Tagastades kodeeritud täisarvu hoidu maagilistest arvudest.
• Funktsioonil ei tohi olla kõrvalmõjusid.

Funktsiooni kirjeldus

Kirjeldus: Funktsiooni abil kontrollitakse kas massiivis eksisteerib otsitav väärtus või mitte ning tagastatakse vastav täisarvuna kodeeritud väärtus.

Parameetrid:

• Täisarvude massiiv – massiiv, mille väärtuste hulgast otsitavat leida tuleb.
• Täisarv – massiivi liikmete arv.
• Täisarv – massiivist otsitav väärtus.

Tagastus: täisarv – kas otsitav väärtus leiti või ei leitud.

Testimine

Edasijõudnute ülesanne 2: n-kordsed uude massiivi.

• Kasutaja sisestab kordaja (positiivne täisarv). Korduvkasuta juba eksisteerivat funktsiooni!
• Loo funktsioon, mille käigus koostatakse uus massiiv
  • Liikmeteks lisatakse algsest massiivist vaid sellised arvud, mille absoluutväärtus on n-kordne sisestatud kordajast. Uude massiivi lisatakse absoluutväärtused algsetest arvudest.
  • Funktsioonil ei tohi olla kõrvalmõju – st ta ei tohi väljastada ümberpaigutatud arve. Samuti ei tohi see ise välja kutsuda funktsiooni, mis seda teeks.
• Trüki välja uue massiivi liikmed. Kasuta mõnda olemasolevat funktsiooni selleks.

E.g.: Input array (-5, 3, -12, 9, 22), multiplier (3), formed array(3, 12, 9)

Testimine

Pärast seda tundi 

• Tead mis vahet on lokaal- ja globaalmuutujal.
• Mõistad mis asi on funktsioon ja miks nende loomine oluline on
• Mõistad, et oleme funktsioone kasutanud juba esimesest nädalast peale. Oleme kasutanud nii funktsioone, mis tagastavad väärtusi, kui ka neid, mis ei tagasta.
• Mõistad, et me saame täpselt samasuguseid funktsioone ise luua ja oskad seda teha.
• Mõistad järgmisi termineid:
  • Funktsiooni prototüüp
  • Funktsioon tagastuse tüüp
  • Funktsiooni argumendid
  • Funktsiooni parameetrid
  • Funktsiooni päis
  • Funktsiooni keha
• Suudad luua korrektseid funktsioone
• Suudad anda funktsioonidesse nii üksikuid väärtusi kui massiive
• Suudad tagastada funktsioonist väärtusi
• Suudad salvestada funktsiooni poolt tagastatud väärtuse
• Suudad funktsioone korduvalt kasutada erinevate argumentidega
• Suudad oma koodi tükeldada funktsioonideks
• Omad lühikest loetelu universaalsetest funktsioonidest, mida sa saad tulevikus kasutada! See loetelu täieneb iga nädal!

Täiendav materjali

• https://www.tutorialspoint.com/computer_programming/computer_programming_functions.htm
• https://www.studytonight.com/c/user-defined-functions-in-c.php

Labori materjal

• Slaidid: Failid
• Näide: Faili nimetus käsurea argumendina
• Näide: Mitme faili korraga kasutamine

Esitamisele kuuluvad ülesanded

Selles laboris on 2 ülesannet, millest mõlemale on edasijõudnute ülesanded laiendusena.

Ülesanne 1: paaris/paaritu

Selle ülesande peamiseks eesmärgiks on harjutada mitme faili korraga käsitlemist ning selle korrektselt tegemist.

Nõuded

• Sisendfailist loetakse teadmata kogus täisarve, mis on eraldatud tühiku või reavahetusega. Arve võib olla lõpmata palju.
  • Näiteks: 5 3 -6 0 25 955 -1024
• Arvud jaotatakse lähtuvalt järgnevatele põhimõtetele:
  • Nulliga võrdsed või väiksemaid arve ignoreeritakse.
  • Positiivsed paarisarvud salvestatakse faili paaris.txt
  • Positiivsed paaritud arvud salvestatakse faili paaritud.txt
• Jälgida tuleb elementaarseid failide käitlemise reegleid
  • Faili avamist kontrollitakse alati
  • Kui fail ei avane siis sellest teavitatakse kasutajat, sealjuures täpsustatakse ka milline fail ei avanenud.
  • Failid sulgetakse enne programmi lõppu
• Kui sisendfailis on vales formaadis sisend peab programm töö katkestama.
  • Näiteks 9 -5 hey 14

Hoiatused ja vihjed!

• Ole väga ettevaatlik lõpmatute tsüklitega olukorras kus toimub ka faili kirjutamine – võid oma kettaruumi mõne sekundiga täis kirjutada.
• Jäta vähemalt testimise ajaks ekraanile väljatrükk iga loetud numbri kohta ning millisesse faili see kirjutatakse. Sedasi on lihtsam aru saada kui midagi läheb valesti ja saad kiiresti katkestada programmi ( ctrl+c ) kui tekib lõpmatu tsükkel).
• Kui esimene fail õnnestus avada, kuid teine mitte, siis enne väljumist tuleb esimene kinni panna!

Edasijõudnute ülesanne 1: statistikute leidmine

Leia järgnevad statistikud:

• Täisarvude summa ja aritmeetiline keskmine
• Vähim ja suurim arv
• Kõik tulemused tuleb leida terve sisendfaili ulatuses olenemata arvust (sh negatiivsetest arvudest!).
• Korduv faili lugemine pole lubatud selle ülesande lahendamiseks.
• Programm peab jätkuvalt töötama lõpmata paljude arvudega.

Edasijõudnute ülesanne 2: käsurea argumendid

Lisa programmile käsurea argumentide tugi. Muuda programmi järgnevalt

• Sisendfaili nimetus loetakse alati käsurealt.
  • Kui faili nimetust ei anta kuvatakse veateade ning programm sulgeb end
  • Faili nimetus on alati esimene argument programmile
• Verbose ehk jutukas
  • Programm peab tuvastama argumendina -v  ehk verbose
  • Programm kuvab iga faili avamise järel mis fail avati (nimeliselt)
  • Programm kuvab iga sisendist loetud numbri ning millisesse väljundfaili see kirjutati
  • Programm kuvab iga faili sulgemise
  • Kui verbose ei ole aktiivne, ei tohi programm ühtegi rida teksti kuvada (välja arvatud veateated ja edasijõudnute ülesanne 1 väljund)

Mõlemad argumendid on laialtlevinud praktikad käsureaprogrammide puhul, kuid leiavad sageli kasutamist ka graafilistes programmides.

Programmi käivitamise näited mis peavad olema toetatud:

• ./parity input_nums.txt
• ./parity input_nums.txt -v

Ülesanne 2: Hoiatustrahvide menetlemine

Ülesande eesmärgiks on luua programm, mis menetleb kiiruskaamerate poolt mõõdetud kiiruseületamisi.

Taustteave

Ülesanne on koostatud avaliku informatsiooni põhjal

• https://www.politsei.ee/et/juhend/kiiruskaamerad/korduma-kippuvad-kusimused
• https://transpordiamet.ee/maanteed-veeteed-ohuruum/liikluskorraldus/kiiruskaamerad

Trahvi koostamise põhimõtted

• Seadme mõõtemääramatus on 4 km/h (50 – 90 km/h alad).
• Menetlust alustatakse, kui kiirust ületati vähemalt 3 km/h.
• Iga piirkiirust ületatud km/h eest tuleb tasuda 5€.
• Maksimaalne trahvisumma on 300€.
• Kui lubatud kiirust ületati 50 km/h tuleb alustada üldmenetlust.
• Näiteks: sõites 90 km/h alas kaamerasse 99 km/h tuleb määrata hoiatustrahviks 25€.

Sisendfail

Lae alla testandmetega sisendfail: 14_2_speeds.txt

Sisendfailis on üks mõõtetulemus rea kohta. Sisendfaili struktuur: <auto registreerimisnumber> <mõõdetud kiirus> <piirkiirus>

• Auto registreerimismärk – kuni 9 tähemärki pikk sõne
• Mõõdetud kiirus – positiivne täisarv
• Piirkiirus – positiivne täisarv.

Loodavad väljundfailid

Programmi tulemusena luuakse 2 väljundfaili – hoiatustrahvid ja üldmenetluse teated.

Esimese loodava väljundfaili sisuks on hoiatustrahvid. St sinna faili tohib kirjutada vaid trahviteatised, mis tuleks sõidukiomanikel tasuda. Iga hoiatustrahv kirjutatakse eraldi reale. Iga rea kohta on  kolm andmevälja:

• Numbrimärk
• Kiiruseületus ilma mõõtemääramatuseta (mitu km/h üle piirkiiruse sõideti)
• Trahvisumma (kiiruseületamisele vastav hoiatustrahv)

Oodatav tulemus:

Teise loodava väljundfaili sisuks on üldmenetluse teated. St sinna tohib vaid kirjutada need, kelle suhtes alustatakse üldmenetlust. Üldmenetluse teated kirjutatakse järgneva formaadiga:

Oodatav tulemus:

Edasijõudnute ülesanne: seadistatavus

Kuna seadused on pidevas muutumises, siis trahvimäärade koostamiseks kasutatavad väärtused peavad olema lihtsasti seadistatavad. Mõtle välja kõige lihtsam lahendus järgnevate nõuete realiseerimiseks

1. Kiiruseületamise menetlemine peab olema seadistatav:

• Iga ületatud km/h eest makstav summa (nt 3€, 5€, 10€)
• Maksimaalne hoiatustrahvi summa (nt 100€, 190€, 300€)
• Üldmenetluse alustamiseks vajalik kiiruseületus (nt 40 km/h, 61 km/h, 100 km/h)

2. Seadistamine peab olema lihtne aga igapäevaelus nähtamatu

Leia sobiv lahendus programmi seadistatavaks muutmiseks lähtuvalt järgnevatest nõuetest:

• Seadistusvõimaluse lisamine ei tohi muuta programmi igapäevast kasutamist aegavõtvamaks.
  Mõte: Igapäevasel kasutamisel ei soovi politseiametnik aega raisata asjade ümberseadistamisega ega isegi nt olemasoleva seadistuse kinnitamisega.
• Seadistusvõimaluse muudatus peab kehtima senikaua kuniks seda uuesti tehakse.
  Mõte: Olles näiteks pärast seadusemuudatust tarkvara ära seadistanud uutele väärtustele ei soovi sa seda iga päev uuesti teha.
• Seadistuste muutmine ei tohi vajada programmi ümberkompileerimist.
  Mõte: Keegi ei kujutaks ette, et politseiametnik hakkab programme ümber kompileerima keset tööpäeva.

Pärast seda tundi

• peaksid oskama faile avada ja sulgeda
• peaksid oskama kontrollida faili avanemist
• teadma mis vahet on erinevatel faili avamise režiimidel ning kuidas need käituvad vastavalt kas fail eksisteerib või ei eksisteeri
• teadma mis olukordades failid ei avane kui neid avada lugemiseks või kirjutamiseks
• teadma erinevaid failide adresseerimise võimalusi
• teadma mida tähendab failide juures puhverdamine ning mis ohte see võib kaasa tuua
• oskama faile lugeda ja kirjutada

Täiendav materjal

• Basics: file handling in C
  https://www.geeksforgeeks.org/basics-file-handling-c/
• FILE data type
  https://cplusplus.com/reference/cstdio/FILE/

Labori materjal

• Slaidid: Sõned
• Näide: mõningad lihtsamad tähemärkide omistamised

Esitamisele kuuluvad ülesanded

Selles tunnis on 2 ülesannet, millest esimeses õpime tundma string.h teeki ning teises manipuleerime tähemärke käsitsi.

Ülesanne 1: string.h teegiga tutvumine

Selle ülesande käigus loome ühe programmi, mille käigus tutvume peamiselt erinevate string.h teegis olevate funktsioonidega.

Nõuded

• Programmi koostamiseks liigu samm-sammult juhendis antud järjekorras.
• Programmi käivitades küsitakse kasutajalt parooli. Enne õige parooli sisestamist ei tohi programm edasi minna.
• Kasutajalt loetakse lause. Programm kuvab mitu tähemärki lauses oli (sh tühikud, kirjavahemärgid).
• Kasutajalt loetakse otsingufraas. Seejärel väljastatakse kas eelnevalt sisestatud lauses see fraas esines või mite (jah/ei vastus).
• Kasutajalt küsitakse 2 sõna, mida kasutatakse lause moodustamisel.
  • Sõnade tüübid võid ise valida (nt nimi, ese, omadussõna, tegusõna, …)
  • Kleebi kasutaja poolt sisestatud sõnad kokku, lisades enda poolt täiendavaid sõnu moodustamaks vähemalt neljast sõnast koosneva lihtlause.
  • Üks kasutaja sisestatud sõnadest peab olema selle lauses esimene sõna.
  • Moodustatav lause tuleb salvestada täiesti uude tähemärgimassiivi, mis peab mahutama selle lause ka siis, kui loetud 2 sõna olid maksimaalse lubatud pikkusega.

Abifunktsioon

Kui sul tekib ühel või teisel hetkel probleeme aru saamisega mis sul tekstimassiivi sisuna salvestatud on, siis võid seda funktsiooni kasutada. Antud funktsioon trükib välja tervikliku sõne, misjärel trükitakse kõik tähemärgid ja selle vastavad ASCII tabeli täisarvulised väärtused. Nii on hea lihtne tuvastada kui näiteks mõni reavahetus või muu imelik sümbol jääb massiivi sisse.

Juhend

1. samm: kasutaja sisestuse lugemine

Esimese sammu teeme tunnis koos läbi! Selle käigus loome me 2 vajalikku funktsiooni oma programmi.

Alustame esimesest mida kasutame sõne lugemiseks. Lahenduses on oluline, et me suudaksime lugeda mitmetest sõnadest koosnevaid sõnesid ehk tühik ei tohiks meil lugemist ära lõpetada! Selleks on mitmeid viise, kuid meie läheneme ülesandele kasutades funktsiooni fgets() . Soovi korral võid ise teist teed minna.

Funktsiooni fgets()  eripäradeks on, et ta on mõeldud lugemaks failist. Küll aga kõik asjad on failid, sh ka klaviatuurilt tulev andmevoog, seega saame kasutada failina stdin  nimelist faili. Teine keerukus antud funktsiooni juures on see, et ta vajab endale pikkust palju tohib lugeda – see on tegelikult ohutuse tagamiseks, et puhvri pikkusest üle ei loetaks. Kolmas ja kõige probleemsem on see, et kui me vajutame klaviatuurilt enter klahvi, siis see reavahetus \n  salvestatakse samuti sinna massiivi.

Lähenemises kasutame põhimõtet, et loome funktsioonidele wrapperid ehk ümbritseme need täiendavate lausetega, mis funktsiooni kasutamise meeldivamaks või mugavamaks muudavad meie jaoks.

Meie ümbrisel on vaja kahte sisendit – sõnet ehk tähemärgimassiivi kuhu loetava teksti salvestame ning kui suur see tekstimassiiv loomise hetkel oli, et me lubatud pikkusest üle ei kirjutaks ja programmi rünnata sedasi ei lubaks.

Antud lahenduses olen jätnud kolme kohta küsimärgid sisse, kus pead ise lüngad täitma! Vihjeks: kui loetud stringi pikkus on 10 tähemärki, siis indeksiga 8 on meie jaoks viimane oluline tähemärk mille kasutaja sisestas. Sellele järgneb meile ebasoovitav reavahetus, millest peame lahti saada, asendades selle sõne lõpu sümboliga.

Vajadusel kasuta varasemalt välja toodud abifunktsiooni!

Selleks, et funktsioon ka kompileeruks olen need 2 täiendavalt vajalikku rida välja kommenteerinud. Olles küsimärgid asendanud kommenteeri need sisse.

Kui lugemine on valmis, loome järgmise ümbrise oma vastloodud GetString()  funktsioonile. Nii saame mugavalt sisestust küsida!

Nüüd kui soovime mõnda sõnet lugeda, saame oma väljakutse luua üsna mugavalt. Näiteks kui meil on tähemärgimassiiv sentence[]  mille pikkus on defineeritud makroga MAX_STR , saame väljakutse luua

2. samm: lause lugemine ja selle pikkus

Loe kasutajalt sisse lause. Seejärel leia ja väljasta sisestatud lause pikkus.

3. samm: fraasi otsimine

Lisa programmi funktsioon, milles küsitakse kasutajalt otsingufraas. Programm väljastab seepeale kas see fraas eksisteeris varasemalt sisestatud lauses või mitte.

Jah-ei vastuseks piisab kui kontrollida tagastust järgneval kujul

4. samm: parooli küsimine

Lisa programmi funktsioon, mis küsib kasutajalt parooli. Näiteks:

Parooli küsimine peab olema tsüklis ja küsima kasutajalt parooli senikaua, kuniks kasutaja sisestab korrektse parooli. Parooli kontroll peab olema tõstutundlik (st suuri ja väiketähti ei võrdsustata). Soovi korral võid panna programmi vale parooli puhul vihjeid andma või end sulgema pärast korduvalt parooli valesti sisestamist.

5. samm: lause moodustamine

Lisa programmi funktsioon, mille käigus moodustad lihtlause. Kuna funktsioonile meil head sisendit ega tagastust anda ei ole, võiksid alustada funktsiooni sedasi (void-void funktsioonid on erandlikud ja enamasti tuleb neid vältida!):

Mõttekoht: kui pikk peaks olema sentence  massiivi pikkus, et see mahutaks halvimal juhul ära mõlemad kasutaja sisestatud sõnad ning sinu lisatavad sõnad, tühikud ja kirjavahemärgid, et moodustada lauset? Suurus võib olla liigkaudne aga peab olema piisav!

Edasi mõtle välja millist lauset moodustada soovid. Oluline on, et selles lauses oleks kaks lünka, kuhu kasutaja sisestab enda soovitud sõnad (ise otsustad millised – nt inimese nimi, ese, nimisõna, tegusõna, …). Üks nendest sõnadest peab olema lause esimene sõna, teise asukoht on sinu enda otsustada. Näiteks <sõna1> on <sõna2> nimi! .

Olles kasutajalt sõnad pärinud ja programmi sisse lugenud tuleb sul need sõnad lauseks kokku kleepida. Kokku kleebitav lause peab olema salvestatud täiesti uude tühja tähemärgimassiivi. Oluline on arvestada, et mis iganes kasutaja sisestab (lubatud pikkuste raames) peab ära mahtuma sinna koostatavasse massiivi ka sellisel juhul, kui kasutaja otsustas maksimaalselt pikad sõnad sisestada.

Näide

Lisaülesanne: Tähtede loendus

Loo käsitsi uus loendamise funktsioon ning väljasta statistika

• Loenda ja kuva mitu tähte [a-zA-Z] oli lauses. Ära loenda kirjavahemärke, tühikuid jne.
• Leia ja kuva mitu protsenti kogu lausest moodustasid tühikud, kirjavahemärgid ja muud sümbolid.
• Näita protsent ühe komakohaga.

Näide

Ülesanne 2: CSV-st meiliaadresside genereerimine

Selle ülesande eesmärk on sulle tutvustada laialtlevinud andmeformaati CSV (comma separated value). Ülesande lahendamise käigus saad harjutada üksikute tähemärkide tuvastamist ja töötlemist.

Lae alla ülesande aluskood: 12_2_csv_starter.c

CSV formaat

CSV on struktuursete andmete hoiustamise formaat, kus iga andmeväli on eraldatud eelnevast ja järgnevast komaga. Tegu on tõenäoliselt kõige levinuma andmete varundamiseks ja hoiustamiseks  kasutatava formaadiga väljaspool andmebaasisüsteeme. Tema peamisteks eelisteks on lihtne struktuur ning sellest tingitult on CSV toetatud praktiliselt kõigis rakendustes, mis vähekegi andmetega töötlevad.

Kõige lihtsamal kujul nagu öeldud on kõik väljad eraldatud üksteisest komaga. Näiteks:

Täpselt sellise keerukusega andmeid vaatame ka selles tunnitöös. Nägemaks keerulisemaid formaate ja reegleid kuidas hoiustada väljasid, mis peavad sisaldama komasid, jutumärke ning kuidas lisada pealkirju võid lugeda siit: https://en.wikipedia.org/wiki/Comma-separated_values#Basic_rules. 

Nõuded

• Ülesande lahendus on ehitatud antud aluskoodile
• Programm loob igale aluskoodis antud inimesele e-postiaadressi.
  • e-postiaadressi nimeosa koosneb kolmest eesnimetähest ja kolmest perenimetähest.
  • Nimeosale järgneb sinu valitud domeen.
  • E-postiaadressi nimi ja domeen peavad koosnema vaid väiketähtedest.
  • E-postiaadress tuleb salvestada terviklikult tekstimassiivi (loo uus muutuja seal kus vaja) ja väljastada selle kaudu. Jooksvalt tähemärkhaaval väljastus pole lubatud.
• Programm väljastab:
  • Inimese täisnime. Eesnime ja perenime osa peavad olema eraldatud tühikuga
  • Genereeritud e-postiaadressi.
• Aluskoodis juba olevat koodi ülesande lahendamiseks muuta ei tohi ilma juhendaja poolse nõusolekuta. Sinu poolt kirjutatava lahenduse alguspunkt peaks asuma  ProcessPerson()   funktsiooni sees. Soovi korral võid julgelt funktsioone juurde lisada.

Näide

Vihjed

• Teades koma asukohta, tead ka mis indeksilt algab perenime esimene täht
• ASCII suur- ja väiketäht erinevad üksteisest ühe biti võtta, mille järgu väärtuseks on 32 (nt A 65, a 97)
• Kõik toimingud peale e-mailiaadressi lõpu lisamise on kõige lihtsam teha selles ülesandes tähemärk-haaval. Saab ka kasutada string.h  teegi funktsioone, kuid need võivad olla asjatult keerukad.
• Kõige tüüpilisem viga selles ülesandes on unustada sõnele null-baidi ehk terminaatori lõppu lisamist pärast nimeosa koostamist!

Lisaülesanne 1: lühikesed nimed

Muuda oma e-postiaadresside genereerimise algoritmi sedasi, et see tuleks toime ka lühemate nimede puhul.

Näiteks: Ly Kask -> lykask@ttu.ee

Lisaülesanne 2: unikaalsed e-postiaadressid

Muuda oma e-postiaadresside genereerimise algoritmi sedasi, et see genereeriks unikaalseid postiaadresse ka siis kui nimel on sarnane algus.

Muuda oma data massiiv järgnevaks:

Nõuded

• Loodavad e-postiaadressid peavad olema unikaalsed
• Aadressi nimeosa peab jätkuvalt olema 6 tähemärki
• Aadressid peavad jätkuvalt viitama nime omanikule nii palju kui võimalik
• Täpne algoritm ja seega saavutatav nimekuju on sinu enda valida. Põhjenda valitud lahendust kaitsmisel.

Pärast tundi peaksid

• Teadma, et tähemärkide jaoks kasutatakse erinevaid kodeeringuid, muuhulgas ASCII ja Unicode
• Teadma mis on ASCII tabel ning kuidas seda kasutada.
• Teadma kuidas töötavad sõned C keeles.
• Teadma kuidas lõpetatakse sõnet C keeles (null-terminaator/null-bait).
• Seostama C keelseid sõnesid baidijadadega.
• Teadma mis on CSV.
• Oskama kasutada string.h teeki sõnede manipuleerimiseks.
• Oskama ka ise kirjutada sõnede manipulatsioone (tähemärkhaaval lähenemine).
• Teadma mis asi on puhvri ületäitumine ning selle kaudu tehtavatest rünnakutest.

Täiendav materjal

• Characters, Symbols and the Unicode Miracle – Computerphile
  https://www.youtube.com/watch?v=MijmeoH9LT4
• A beginners guide away from scanf
  https://www.sekrit.de/webdocs/c/beginners-guide-away-from-scanf.html
• ASCII
  https://en.wikipedia.org/wiki/ASCII
• ASCII table
  https://www.rapidtables.com/code/text/ascii-table.html
• Character encoding
  https://en.wikipedia.org/wiki/Character_encoding
• String.h library
  https://www.cplusplus.com/reference/cstring/
• Strings in C
  https://www.geeksforgeeks.org/strings-in-c-2/
• CSV
  https://en.wikipedia.org/wiki/Comma-separated_values

Labori materjal

• Slaidid: Standardvood
• Slaidid: Pseudojuhuarvud
• Täiendav: voo suunamise juhend

Esitamisele kuuluvad ülesanded

Selles laboris on kaks ülesannet, millest mõlemale on laiendusena pakutud välja lisaülesanne.

Ülesanne 1: kuupäeva kontroll

Ülesande eesmärgiks on tuvastada kas sisestatud kuupäev on tõene või vigane. Ülesande raames tutvume ka voo suunamisega.

Lae alla ülesande aluskood: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/8_1_date_base.c

Nõuded

• Programm kuvab iga kuupäeva puhul kas tegu on reaalse või vigase kuupäeva.
• Aastate vahemik on piiratud 1900 – 2099
• Programmis on rakendatud liigaasta kontroll
• Maksimaalselt töötleb 100 kuupäeva
• Kuupäevad vastavad kõik formaadile DDMMYYYY .
  • NB! Kuupäevade formaadid on konkreetselt määratletud.
    https://en.wikipedia.org/wiki/Date_format_by_country
• Baasülesande raames tuleb lahendada funktsioonid sellisel kujul nagu nad antud on.  Kohustuslike funktsioonide loetelu ja kommentaarid leiad aluskoodist.
• Programmi esitades pead seda tegema kasutades sisendvoo ümbersuunamist. Sisendiks on fail, mis sisaldab endas sellel lehel antud testkuupäevasid.

Algoritm

NB! Algoritm näitab meile üldisemat ideed ülesande lahenduskäigust ning on eelkõige informatiivse väärtusega. Algoritmis ei kajastu kuidas võiks toimida andmevahetus funktsioonidega. Samuti on funktsioonide kasutamisest tulenevalt mõningad järjestusest teistmoodi.

Samm-sammuline lahendamisjuhend

Alususeks peame tegema andmefaili. Sinna kirjutame samad andmed, mida muidu trükiksime klaviatuurilt iga kord programmi testides. Teisisõnu kirjutame oma testandmed ühekordselt ära ja hiljem lihtsustame oma testimist sedasi. Mõnel ülesandel võib taolisi testfaile olla mitu, mõnel piisab ühest.

Lähtefaili kirjutades tuleks arvestada kõikvõimalike erinevate juhtudega,  mis programmis esineda võivad. Kindlasti tuleb testida nii sobilike kui ka mittesobivaid kuupäevi. Näiteks võib siin olla tavapäraseid kuupäevi – 11. detsember 1981, kuid samuti ka ebareaalseid kuupäevi – 51. detsember, kuu nr 22 jne. Eriti olulised on piirjuhud – nt 29. veebruar liigaastal ja tavapärasel aastal. Järgnevalt on välja pakutud üks võimalik loetelu kuupäevi (võid julgelt kuupäevi lisada loetelu lõppu, kuid need peavad kindlasti sisalduma testis).

Siin on sinu testsisend. Salvesta see tekstifailina samasse kausta kuhu oma programmi paned!

Järgmiseks oleks meil vaja programmi, mis neid kontrollima hakkaks.

Nüüd hakkame töötama ette antud aluskoodiga. Esimesed kaks funktsiooni teeme tunnis koos ära! Kui tunnis polnud, vaata loengusalvestust!

Nüüd peaks meil olema 2 faili, mõlemad samas kaustas:

1. Programmikood (nt date.c )
2. Tekstifail sisendandmetega (nt input või input.txt )

Järgmisena on meil vaja programmi. Üks valik programmi loomiseks on see kompileerida läbi Geany või mõne teise rakenduse mida oled senimaani kasutanud. Võid seda julgelt teha kui end sedasi mugavamalt tunned. Ära vaid unusta iga kord uuesti kompileerimast pärast muudatusi!

Veendume, et failid on kõik seal, kus peaks kasutades käsku ls -l :

Kui varem oli meil 2 faili, siis nüüd peaks neid olema 3:

• date  – nn binaarfail ehk programm, mis loodi lähtekoodi kompileerimise tulemusena. Käivitatav!
• date.c  – lähtekoodi fail. Siia kirjutame me tekstiredaktoriga koodi, ei ole käivitatav programmina!
• input.txt  – tekstifail, mis sisaldab kuupäevi ehk testandmed.

Nüüd käivitame programmi sedasi, et klaviatuurilt trükkimise asemel loetakse andmed ette söödetud failist (kasutades voo ümbersuunamist). Selleks saame kasutada järgmist struktuuri, asendades failid õigete nimedega: ./programminimi < andmefailinimi

./programminimi – sedasi saad programmi käima Linuxis käsurealt
< – tähistab, et programmi klaviatuurilt tulevad sisestused juhitakse ümber
andmefailinimi – siit hakatakse lugema mida programmile ette sööta ehk siis kust sisestus tuleb

Siin lõppeb tunnis koos tehtav osa ning algab iseseisev töö. Selleks hetkeks peaks programmi väljund olema järgmine

Testimine: valmislahendus

Pärast programmi valmimist peaks su väljund nägema välja samasugune nagu siin.

Ülesanne 2: loto

Lae alla ülesande aluskood:

• Eestikeelsete kommentaaridega: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/8_2_loto_base.c
• Ingliskeelsete kommentaaridega: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/8_2_loto_base_en.c

Nõuded

• Tunnitöö tuleb ehitada ette antud aluskoodile.  Aluskood on sulle antud ning sisaldab juba funktsioonide loetelu funktsioonidest koos kommentaaridega mis tuleb sul realiseerida ja kasutusele võtta.
• Lotonumbrid genereeritakse vahemikus 1 … 25 (otspunktid kaasaarvatud).
• Kasutajalt küsitakse 6 arvu (lotonumbrid).
• Programm genereerib juhuarvudena 10 arvu (võidunumbrid).
• Programm kuvab genereeritud võidunumbrid
• Kontrolli ja näita mitu ja millised numbrid kattusid.
  • Baasülesandes pole nõutud numbrite unikaalsus
  • Iga lotonumber saab kattuda võidunumbriga vaid ühel korral.
• Kui kõik numbrid kattusid, õnnitle peavõidu korral. Kui ükski ei kattunud, avalda kaastunnet.

Testimine

NB! Kuna loterii nagu nimigi ütleb on juhuslik, siis selle testimisel tuleks juhuarvu seeme (srand funktsiooni argument) määrata konstandiks. Genereeri ühe korral lototroni numbrid ära ja jäta need meelde, et saaksid testi tulemusi kergelt korrata!

Test 1: Juhuslikud arvud, mõni võidunumber, sisestus OK.

Test 2: Võidunumbrid puuduvad

Test 3: Jackpot

Test 4: Vigane sisestus

Test 5: Iga number võidab vaid korra (absurdsed olukorrad – sanity check)

Antud testis teeme muudatuse oma lähtenõuetes, et testida mitu korda üks lotonumber võita saab. Kaine mõistus ütleb, et iga number saab võita vaid korra.

NB! See test töötab selliselt vaid siis kui unikaalsuse nõue ei ole täidetud (st pole tehtud lisaülesanne). Korduvad numbrid on seega lubatud.

Antud testi juures saame jälgida kusjuures kahte erinevat asja

1. Jälgi võitude arvu! St Matched 6 out of 6!)
2. Jälgi lototroni genereeritud numbreid. Need tohivad olla vaid ühed! (0 või 2 esinemine tähendab, et sul on viga juharvude valemi koostamisel!)

Märkus: Tunnitöö baasülesandes vaatleme vai lihtsalt juhtu, kus kasutaja arv saab võita ühekordselt. Näiteks kui kasutaja sisestab numbrid “1, 1, 1, 1, 1, 1” ja lototron genereerib “1, 2, 3, 4, 5, 6, 7, 8, 9, 10”, siis baasülesande raames piisab, kui loeme, et iga kokku tuli 6 tabamust. Kui aga kasutaja numbrid oleksid “1, 2, 3, 4, 5, 6” ja lototron genereeriks “1, 1, 1, 1, 1, 1, 1, 1, 1, 1”, siis oleks olnud vaid 1 tabamus.

Lisaülesanne 1: mittekorrektse kuupäeva põhjendus

Algse lahenduse puudujäägiks oli ebaselgus miks üks või teine kuupäev ei valideerunud. Täiendame oma programmi sedasi, et ka põhjus oleks arusaadav.

Nõuded

• Laienda oma programmi nii, et programm põhjendaks miks kuupäev reaalseks ei osutu
• Minimaalselt pead eristama
  • Ebasobivat aasta väärtust
  • Ebasobivat kuu väärtust
  • Ebasobivat päevade arvu, eristades sealjuures väiksemat ja suuremat kui lubatud väärtust
  • Mitte-liigaastal olevat 29ndat veebruari
• Lahenduses võid lisada täiendavaid funktsioone ja muuta mõistuse piires ka olemasolevat programmi struktuuri.
• Meeldetuletus! Väldi maagilisi arve!

Testimine

Lisaülesanne 2: lototronile unikaalsed numbrid

Selle ülesande eesmärk on muuta ülesanne täisväärtuslikuks. Selleks on meil vaja lahendada vaid üks funktsioon FindMatchCount()  ning seda õigetes kohtades kasutusele võtta.

Nõuded

• Kasutaja poolt sisestatavatele numbritele tuleb rakendada unikaalsuse nõue. Kui kasutaja sisestab korduva numbri, tuleb see sama number uuesti küsida.
• Lototronile tuleb rakendada unikaalsuse nõue. Lototroni poolt genereeritavad võidunumbrid ei tohi korduda.
• Lahenduse käigus ei tohiks muuta GetUserNumbInRange()  ja GenerateRandomNum()  funktsioone, otsi selleks sobilikum koht.
• Kommenteeri sisse ja lahenda ära funktsioon CheckIfNumInArray() . Võta see funktsioon kasutusele kolmes kohas
  1. Kasutaja lotonumbrite unikaalsuse kontrolliks
  2. Lototroni genereeritud võidunumbrite unikaalsuse kontrolliks
  3. Kasutaja ja lotoarvude kattuvuse leidmise funktsioonis FindMatchCount()

Testimine

Test 1: Kontrollime unikaalsuse nõuet kasutajale

NB! Kontrolli kindlasti kasutades sama jada!

Test 2: Kontrollime unikaalsuse töötamist lototroni poolt

Selleks, et kontrollida lototroni tööd peame me jällegi manipuleerima konstante.

Selle testiga on meil arvuti poolt genereeritud numbrite arv täpselt sama suur kui maksimaalne unikaalsete numbrite arv. St kõik numbrid 1 – 10 peavad saama genereeritud ning ükski neist korduda ei tohi.

Mõtle ja vasta ka küsimusele mis juhtuks kui oleksime konstandi pannud 9 peale?

Pärast tundi peaksid

• Teadma millised standardvood eksisteerivad
• Oskama kasutada voo suunamist erinevatel platvormidel
• Oskama käivitada enda kompileeritud programme Linuxi käsurealt
• Oskama kasutada tõeväärtusi (boolean andmetüüp)
• Oskama tükeldada sisestust vajadusel tähemärkhaaval
• Oskama kasutada scanf poolt taastatavat väärtust
• Oskama kasutada üherealisi tingimuslauseid ja tsükleid
• Oskama genereerida pseudojuhuarve
  • .. pannes need alati algama samast arvust
  • .. pannes need kellaajast sõltuvaks
• Teadma mis vahet on pseudojuhuarvul ja juhuarvul
• Oskama piirata juhuarvude genereerimise vahemikku
• Teadma mis on ning kuidas töötab UNIXi kellaaeg, sh mis tähtsus on 1. jaanuaril 1970.

Täiendav materjal

• Boolean type support library
  https://en.cppreference.com/w/c/types/boolean
• What is a leap year
  https://www.timeanddate.com/date/leapyear.html
• Standard streams
  https://en.wikipedia.org/wiki/Standard_streams
• Redirection
  https://en.wikipedia.org/wiki/Redirection_(computing)
• Pseudorandomness
  https://en.wikipedia.org/wiki/Pseudorandomness
• Why does Cloudflare use lava lamps to help with encryption? (üks võimalik lahendus pseudojuhuslikkuse probleemile)
  https://www.cloudflare.com/learning/ssl/lava-lamp-encryption/
• Unix time
  https://en.wikipedia.org/wiki/Unix_time
• Unixi praegune kellaaeg ja selle teisendi
  https://www.unixtimestamp.com
• rand() and srand() in C/C++
  https://www.geeksforgeeks.org/rand-and-srand-in-ccpp/
• time.h library in C
  https://www.cplusplus.com/reference/ctime/

Teooriat ja meeldetuletusi

Tähemärk, sõne ja väljastusfunktsioonid

Kuigi sõnede juurde tuleme alles mõne nädala pärast võime mõnda omadust ikkagi vaadata.

Sõne (string) tähendab järjestatud tähemärkide jada. St selleks võib olla arusaadav sõna või lause, kuid võib olla ka arusaamatu erinevate sümbolite jada. Sõned on alati jutumärkide vahel.

Näited:

• • "a"
  • "Hello!"
  • "I do wish we could chat longer, but I'm having an old friend for dinner."
  • "lFRD=)m+0FDj2"

Üksikut tähemärki hoiame aga ülakomade vahel. Sõne koosneb sellistest tähemärkidest. NB! Kaldkriipsuga hakkavad erisümbolid (escape sequence) ja neid loetakse üheks tähemärgiks (nt \n  on üks tähemärk arvuti mälus).

Näited:

• • 'a'
  • 'y'
  • '\n'
  • '\t'

Funktsioonid mida saame kasutada teksti väljastamiseks

• printf()  ehk print formatted. Tegu on kõige keerukamaga seniõpitutest, mille abil saame trükkida kujundatud teksti, mille abil saame ka kõiksugu muutujate sisu väljastada. Reavahetus käib käsitsi!
  Näiteks: printf("Hello, %s!\n", name);
• puts()  ehk put string. Tegu on lihtsa funktsiooniga mis on mõeldud ühe tekstilõigu kuvamiseks. See ei toeta keerukaid formaate ega muutujatest teksti väljastamist. Reavahetus lisatakse automaatselt.
  Näiteks: puts("Hello, user!");
• putchar()  ehk put character. See on kõige lihtsam funktsioon neist kõigist. Selle abil saab väljastada vaid ühe tähemärgi. Seda on mugav kasutada nt reavahetuse trükkimiseks.
  Näiteks: putchar('\n');

Massiivi edastamine funktsiooni

Massiive alamfunktsioonidesse edastades andsime edasi viite originaalile – st me saame edastatud massiivi muuta ilma tagastamata ja olenemata kohast.

Reeglina tuleb alati massiiviga koos edastada selle kõigi dimensioonide suurused. Pärast funktsiooni edastamist neid suurusi välja arvutada enam ei ole võimalik! Erandiks on sõned (string), millest räägime tulevikus.

Mõned eripärad edastamisel

• Kui soovid edastada tervet massiivi, olenemata selle dimensioonide arvust, täpsustame vaid selle massiivi nime Func(numbers);
• Kui soovid 1-dimensioonilisest massiivist int numbers[N];  edastada vaid ühe väärtuse, täpsustame selle indeksi Func(numbers[2]); . Funktsioonis käsitle seda ühte arvu  Func(int val);
• Kui soovid 2-dimensioonilisest massiivist ( int numbers[N][M];  edastada rea alguse, täpsustame selle indeksi ja pikkuse Func(numbers[2], M); . Funktsioonis käsitle seda kui 1-dimensioonilist massiivi  Func(int numbs[], int n);
• Kui soovid 2-dimensioonilisest massiivist int numbers[N][M];  edastada vaid ühe väärtuse, täpsustame selle indeksi Func(numbers[2][1]);

Kahe arvu omavahel vahetamine massiivis

Vahetamaks kahte arvu sobib lahenduseks mullsorteerimise tunnist õpitud vahetamise idee kasutades abimuutujat

Märkus: isegi kui soovid vahetada kahe rea või veeru väärtusi on ikkagi vaja vaid ühte muutujat.

Massiivi kasutamine abimuutuja asemel on mõistlik vaid paralleeltöötlust toetavatele protsessoritele programme kirjutades. Sellised protsessorid põhinevad SIMD (sing-instruction-multiple-data) arhitektuuril – näiteks graafikakaardid (GPU – graphics processing unit).

Massiivide algväärtustamine nulliks

Terve massiivi algväärtustamiseks nulliks paneme soovitud konstandi loogeliste sulgude vahele

Kui tegu on 2-dimensioonilise massiiviga, kasutame kahte komplekti loogelisi sulge.

Esitamisele kuuluvad ülesanded

Selles tunnis tegeleme programmiga, mis töötab senikaua kuniks kasutaja soovib sellest väljuda. Programmi raames tegeleme maatriksi manipuleerimisega.

Alusta näidisprogrammiga tutvumisest, misjärel mine edasi ülesande lahendamise kallale.

Tunnitöö näidisprogramm

Sulle on antud tänasest tunnitööst näidisprogramm. See on antud kompileeritud kujul, st saad selle käivitada ja testida milline selle lõpptulemus peaks välja nägema. Sinu loodav programm peaks lõpuks töötama sarnaselt.

Mõlemad näidisprogrammid on kompileeritud x86-64 arhitektuurile. Garanteeritud töötavad mõlemad laboriarvutitel, kuid peaksid ka töötama enamikel isiklikel arvutitel. Probleeme võib tekkida ARM protsessoritega arvutitel ilma x84-64 emulatsiooni kasutamata.

• Näidisprogramm (Linux)
• Näidisprogramm (Windows)

NB! Linuxil kasutamiseks pead andma failile käivitamisõigused (turvalisus ennekõike!). Õiguste muutmine on ühekordne tegevus. Selleks toimi nii:

See lisab (chmod – change mode) kasutajale (u – user) õigused programmi käivitada (x – execute). Pärast seda tohid programmi käivitada tavapäraselt, st ./program_name

Kirjeldus

Tänane tunnitöö on jaotatud kaheks eraldi hinnatavaks osaks, millele on võimalik juurde teha kolm lisaülesannet

Antud juhul on tegu programmiga, mis töötab kuniks kasutaja soovib sellest väljuda. Seetõttu peame me ka vajadusel jälgima mis seisundis meie maatriks parasjagu on.

Maatriksi maksimaalne suurus mälus on fikseeritud makrotega LIMIT_ROWS ja LIMIT_COLS , mis määravad vastavalt maksimaalse ridade ja veergude arvu. Neid pead eraldi kasutama!

Programmis võib vastavalt kasutaja soovile olla kasutusel parasjagu väiksem osa maatriksist – sellisel juhul jääb lihtsalt otsa maatriksist kasutamata. Seetõttu on funktsioonide prototüüpides igal pool 2 muutujat int rows  ja int cols , mis sisaldavad hetkel kasutusel oleva maatriksi piire.

Lae alla aluskood: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/10_switch_basecode.c

Üldised nõuded

Need nõuded kehtivad olenemata millise osaga programmi lahendamisest tegeled.

• Sinu lahendus peab võimalikult täpselt matkima etteantud näidisprogrammi.
• Töö peab olema ehitatud etteantud aluskoodile.
  • Aluskoodi tohid mõistlikes piirides modifitseerida. Näiteks võib kasu olla tegevuste järjekorra muutmisest main() funktsioonis või funktsioonile GetIntInRange() täiendava parameetri lisamisest. Muudel juhtudel mõtle hoolikalt läbi kas muudatus on ikka mõistlik!
  • Aluskoodis on sinu jaoks juba valmis tehtud 2 funktsiooni, kasuta neid vastavalt vajadusele.
  • Aluskoodis on ette antud kahe esimese funktsiooni prototüübid millest peaksid lahendamist alustama tehes tunnitöö esimest osa.
• Maatriksis olevad arvud on kõik vahemikus 0 – 99.
• Kõik toimingud peavad olema korratavad ilma programmist väljumata.
• Kõigi menüü valikute töötlev pool peab olema lahendatud eraldi funktsioonides.
  • switch()-i sees võid julgelt printida välja abiteksti, salvestada funktsioonidest tagastatavaid väärtusi jne. Äärmisel vajadusel võid ka mõne if lause sinna panna.
  • Täiendavaid tsükleid kindlasti main() funktsiooni kirjutada ei tohi!
• Programm peab olema terviklik ja arusaadav ning töötama kuniks kasutaja soovib sellest ise väljuda.

Tunnitöö osa 1

Esimeses osas loome maatriksi kuvamise ja genereerimise.

Nõuded

• Kasutaja saab genereerida n * m maatriksi
  • Maatriksi liikmeteks on juhuarvud vahemikus 0 – 99
  • n ja m on kasutaja poolt sisestatavad väärtused. Vajadusel loo piirangud kasutaja sisestusele
  • Genereerimise funktsioonis  GenerateMatrix()  tohid kasutada vaid do while()  tüüpi tsükleid.
  • Meeldetuletus: C funktsioonid on lihtsad ja teevad vaid ühte asja (ning teevad seda hästi)! Funktsioon GenerateMatrix() ei tohi tegeleda kasutajalt sisendi küsimisega!
• Kasutaja saab kuvada maatriksit
  • Kuvamise funktsioonis tohid kasutada vaid while()  tüüpi tsükleid
  • Maatriks peab olema viisakalt joondus.
• Kasutaja saab väljuda programmist

Tunnitöö osa 2

Teises tunnitöö osas loome funktsioonid ridade ja veergude omavahel vahetamiseks.

• Kasutaja peab saama vahetada kaks enda valitud rida omavahel ära
  • Vahetamise funktsioonis tohid kasutada vaid for()  tüüpi tsükleid.
• Kasutaja peab saama vahetada kaks enda valitud veergu omavahel

Tüüpilised vead

• Copy-paste ehk korduv kood. Enamasti on selleks sisestus (nt sisesta ridade arv, sisesta veergude arv jne).
• Off by one ehk ühega mööda. Meeldetuletuseks esimene rida on indeksiga 0.
• Maagilised numbrid
• Maatriksi operatsioonide lubamine enne maatriksi genereerimist. Näiteks sa ei saa kuvada maatriksid, mida ei ole veel genereeritud!
• Vale tsükli tüübi kasutamine (Osa 1 ja 2 puhul on fikseeritud milliseid tsükli tüüpe tohid kasutada)
• Ridade ja veergude arvu sassi ajamine. Proovi näiteks
  • genereerida 3 x 5 maatriks, vaheta ära read 1 ja 3
  • genereerida 5 x 3 maatriks, vaheta ära veerud 1 ja 3

Lisaülesanne 1: kustutamine

Lisame täiendava funktsionaalsuse olemasolevasse programmi

• Kasutaja saab kustutada enda valitud rea.
• Kasutaja saab kustutada enda valitud veeru.
• Kustutatud rida või veerg eemaldatakse vahelt, mistõttu järgmised read või veerud tulevad varasemaks. Maatriksi suurus väheneb.
• Lisa vajalik funktsionaalsus menüüsse.

Lisaülesanne 2: lisamine

Lisame täiendava funktsionaalsuse olemasolevasse programmi

• Kasutaja saab soovitud asukohta lisada täiendava rea
• Kasutaja saab soovitud asukohta lisada täiendava veeru
• Kõik elemendid lisatavasse ritta või veergu genereeritakse juhuarvudega
• Kõik read / veerud, mis paiknevad soovitud asukoha järel nihkuvad ühe võrra kaugemale. Maatriksi suurus suureneb.
• Lisa vajalik funktsionaalsus menüüsse.

Lisaülesanne 3: transponeerimine

Lisame täiendava funktsionaalsuse olemasolevasse programmi

• Kasutaja saab maatriksit transponeerida
• Lisa vajalik funktsionaalsus menüüsse.

Pärast seda tundi peaksid

• Oskama luua lõputult kestvaid menüü-programme
• Teadma täiendavaid käske teksti väljastamiseks

Täiendav materjal

• Menu-Driven program using Switch-case in C
  https://www.geeksforgeeks.org/menu-driven-program-using-switch-case-c/
• Escape sequences in C
  https://en.wikipedia.org/wiki/Escape_sequences_in_C

Labori materjal

• Slaidid: Tingimuslaused 2

Esitamisele kuuluvad ülesanded

Ülesanne 1: poekassa

Selle ülesande raames simuleerime läbi lihtsa kassasüsteemi rakenduse, eesmärgiga harjutada tingimuslausete koostamist. Juhindu etteantud aluskoodis olevatest kommentaaridest ning kirjuta vajalikud koodiread pärast kommentaari!

Nõuded

• Programm peab loogiliselt olema üks-ühene etteantud algoritmiga
• Programm peab olema ehitatud etteantud aluskoodi põhjale. Sinu ülesanne on lisada vajalikud printf , scanf  laused, arvutustehted ja tingimuslaused sinna kuhu vaja. Juhindu kommentaaridest ja etteantud UMList.
• Ära muuda muutujate nimetusi ega programmi struktuuri.
• Soovitus: Kontrollimaks, et programm käitub korrektselt ja muutujad omavad neid väärtusi, mida ootad, tasub lisada vahele mõni täiendav printf  lause.

Lae alla ülesande 1 aluskood: [et]

Algoritm

Testimine

Järgnevalt pakun välja mõned olulised testid loodavale programmile. NB! Vähemalt ühe olulise testjuhu olen jätnud katmata. Kas tead millise?

Ülesanne 2: poekaal

Ülesande raames tuleb luua programm, mis simuleerib toidupoes asetsevat toidukaalu.

Tunnis luuakse ülesande struktuur UML tegevusdiagrammina. Sinu programm peab omama vähemalt samaväärset funktsionaalsust.

Nõuded

• Kaalul peab olema kokku vähemalt 4 erinevat tootevalikut.
• Tootevalikud on esindatud numbri (tootekood) ja nime kombinatsioonidega (nt 1 – banaan).
• Kasutaja sisestab klaviatuurilt täisarvulise tootekoodi ja murdarvulise koguse (kilogrammides).
• Valitud tootekoodi ja toote kilohinna vaste leidmine tuleb realiseerida kasutades switch  lauset.
• Korrektse kaalu ja koodi korral väljastatakse kasutajale hind, mis tuleb kauba eest maksta.
• Väljastatav hind peab olema esitatud kahe komakohaga.
• Vigase tootekoodi või kaalu korral tuleb väljastada veateade. Kumma veaga tegu oli tuvastama ei pea. Vea tekkimisel hinda kuvada ei tohi.

Lae alla ülesande 2 aluskood: 2_2_scale_base.c

Testimine

Test 1: Korrektse sisestuse korral antakse tulemuseks hind

Test 2: Vigase tootekoodi puhul antakse veateade
Test 3: Vigase kaalu puhul antakse veateade

Pärast tundi peaksid

• Mõistma mis asi on tõeväärtustabel ja kuidas neid lugeda
• Oskama koostada liittingimusi
• Oskama inversiooni ja tingimuse lühivormi kasutada
• Oskama algväärtustada muutujat deklareerimise hetkel
• Teadma mida De Morgani seadus tähendab
• Oskama koodiplokke üksteise sisse panna tingimuslausete näitel
• Oskama kasutada sama muutujat mõlemal pool võrdlusmärki tehetes
• Oskama kasutada ja väljastada murdarvu (väga lihtsad juhud)
• Oskama kasutada switch lauset koodis
• Oskama modelleerida switch lauset UMLis
• Oskama kasutada ujumisradu (eraldisi, swim lane)
• Oskama luua mitme erineva lõpuga programme

Täiendav materjal

• De Morgan’s Laws
  https://brilliant.org/wiki/de-morgans-laws/
• C/C++ if else if ladder with Examples
  https://www.geeksforgeeks.org/c-c-if-else-if-ladder-with-examples/
• Decision Making in C / C++ (if , if..else, Nested if, if-else-if )
  https://www.geeksforgeeks.org/decision-making-c-c-else-nested-else/
• Exit codes in C/C++ with Examples
  https://www.geeksforgeeks.org/exit-codes-in-c-c-with-examples/
• Switch Statement in C/C++
  https://www.geeksforgeeks.org/switch-statement-cc/

Labori materjal

• Slaidid: Linux_CLI

Käskude abi

Kui soovid abi mõne käsu kohta, siis selleks on sul 3 peamist meetodit.  Kolmas ja mõneti kõige aeglasem on internetist otsimine, seega seda me siin ei kajasta. Ülejäänud 2 infoallikat on aga kättesaadavad otse käsurealt.

tldr (simplified community-driven man pages)

See on Linuxi kasutajate poolt kokku pandud “käsiraamat”, mille eesmärk on kiiresti ja lihtsalt kirjeldada iga programmi kõige levinumad ja olulisemad kasutusviisid. Seetõttu on aga puudujäägiks sageli vajaliku detailsuse või selgituste puudumine.

Vaikimisi seda Linuxitega kaasa ei tule aga oleme selle tööriista laboriarvutitesse paigaldanud.

Kasutamiseks kirjuta käsureal tdlr käsu_nimi

Alternatiiv: kasuta veebist https://tldr.sh

Näiteks lugemaks kuidas faile kopeerida kirjuta tldr cp

man pages

man ehk manual pages on Linuxiga kaasa tulev manuaal. Siin on olemas manuaalid käskudele, teekidele, süsteemi käskudele jne. Enamasti on iga programmi manuaalis kirjeldatud kogu tema funktsionaalsus. Kasutamiseks kirjuta man käsu_nimi

Näiteks lugemaks kuidas faile kopeerida kirjuta man cp

Manuaali sulgemiseks kasuta klahvi q . Manuaalist otsimiseks sisesta /  ning seejärel mida otsida soovid. Abi teiste käskude näed kui vajutad h  klahvi.

man  eelis tldr  ees on põhjalikkus – üldiselt on selgitused väga detailsed ning mõeldud kogenud kasutajale (professionaalile). Sageli on need algajale liialt mahukad.

Esitamisele kuuluvad ülesanded

Selles laboris on kaks ülesannet, millest mõlemat lõppevad lõppevad veebivormiga, mis tuleb täita ja esitada! Eraldi ülesande lahendusi ette näitama ei pea.

Ülesanne 1: käsurea kasutamine

Selle ülesande raames tutvume väga põgusalt käsurea kasutamisega. Ülesanne lõppeb veebivormiga, mis tuleb täita. Veebivormi esitamine kinnitab ülesande lahendamist.

Kasutatavad terminid:

Käsuviip – Käsurea alguses olev informatsioon näitamaks ära kasutajanime ja asukohta failisüsteemis.

Käsurida / käsuaken / terminal – Programm, kus me oma käske jooksutame, nn terminal. Sisaldab käskude ajalugu, käsuviipa, võimalust käsku sisestada jms.

Vali viis ülesande lahendamiseks

Enne kui ülesande juurde saad minna oleks vaja meil Linux keskkonda ja käsuakent. Valikud pakun välja neli.

1. Lahenda ülesande kooliarvutis.
2. Lahenda ülesanne üle kaughalduse
   Juhend: RDP abil kaugligipääs
3. Lahenda ülesanne luues SSH tunnel kooliarvutisse ning tehes kõik üle tunneli
   Juhend: SSH ühenduse loomine

Ülesande lahendamine

Ülesanne on kirjeldatud samm-sammulise töövoona. Kõik tegevused tuleb lahendada kasutades käsurida. Ülesande lõpus tuleb sul esitada oma käskude ajalugu!

Samm 1: Vali kaust kus labori faile hoiad

Esmalt peaksid otsustama kuhu paned selle labori jaoks vajalikud failid. Tõenäoliselt võiks see olla midagi sarnast nagu  ~/P/iax0583/labor11 .

Järgnevad käsud aitavad sind nagiveerimisel ja kausta loomisel:

• Käsk pwd  näitab kus kaustas hetkel asud
• Käsk cd  võimaldab kaustade vahel liikuda
• Käsk mkdir  abil saad luua uue kausta
• Käsk ls  näitab mis praeguse kausta sees asub. kasuta täiendavaid argumente detailide nägemiseks.
• Käsk mv  lubab kaustasid ja faile ümber nimetada ja liigutada.
• Kasuta tldr käsk  või man käsk , et näha abi käsu kasutamise kohta.

Liigu käsureaga kausta, kus ülejäänud labori teha kavatsed!

Samm 2: Lae alla testprogramm

Labori kulgemist jälgib testprogramm. Programm on kokku pakitud kujul.

Failide allalaadimiseks kasutatakse tööriista nimega wget . lae seda kasutades testprogramm alla. Selleks käivita järgnev käsk:

Samm 3: Paki testprogramm lahti ja käivita see

Tegu kokku pakitud zip arhiiviga. Kasuta programmi   unzip selle lahti pakkimiseks. Jälgi hoolikalt arhiivi lahti pakkimise käigus tekkivat väljundit. See on oluline, et teaksid mis lahti pakiti ja kuhu! Soovitavalt tee topeltkontroll kasutades ls -i, et veenduda selles.

Võimalik, et pead ka programmi käivitatavaks muutma

Mõnel juhul võib osutuda, et programmi ei pakitud lahti käivitusõigustega. Kui see nii juhtus (kontrolli esmalt), tuleb käivitusõigus lisada.  Selleks saad kasutada käsku chmod .

Käivita testprogramm

Nüüdsest on sul võimalik testprogrammi käivitada. Tee seda kohe – pane käima alla laetud programm!

Programm kontrollib labori kulgemist ja jääb seisma kohe kui märkab täitmata nõuet. Edaspidi jooksuta testprogrammi iga kord kui oled järgneva sammu ära teinud.

Praegu peaksid nägema järgmist väljundit:

Samm 4: Lae alla Vimi seadefaili

NB! Kui oled juba Vim-i kasutaja ning omad kodukataloogis seadefaili, jäta see samm vahele!

Vim on üks klassikalistest käsureal töötavatest tekstiredaktoritest. Sel on suur kogus erinevaid laiendusi ja seadistusvõimalusi võrreldes primitiivsete tekstiredaktoritega nagu nt nano.

Laeme alla seadefaili, mis teeb selles koodi redigeerimist veidi mugavamaks – nt lisab koodi värvimise, automaatse tabuleerimise jne. Vim’i seadefail tuleb laadida enda kasutaja kodukataloogi – sealt otsib vim seda automaatselt.

1. Mine käsuaknas oma kodukataloogi. Selleks kasuta käsku cd . Kodukataloogi sümboliks on ~ .

2. Kasuta programmi  wget  seadefaili allalaadimiseks. Seadefail asub aadressil  blue.pri.ee/.vimrc

Kasuta testprogrammi kontrollimaks, et seadefaili allalaadimine õnnestus!

Samm 5: Kopeeri üle andmefail, mis sisaldab saladust

Mine M kettale (~/M/). Leia sealt üles oma praktikumi juhendaja kaust ja mine sinna sisse. Selle kausta sees on üks peidetud alamkaust – otsi see üles ja mine sinna sisse. Peidetud alamkausta nimi algab punktiga. Peidetud kausta seest leiadki puuduoleva faili.

Nüüd tuleb sul see fail endale kopeerida. Kopeeri see samasse kausta kus asub su testprogramm! Kopeerimiseks pead kasutama käsku  cp . Määra ära mida soovid kopeerida ja kuhu!

Nüüd on aeg jälle testprogramm käivitada ja vaadata kas saladus leiti.

Samm 6: Järgmiseks pead looma tekstifaili oma matriklinumbriga

Loodava faili nimeks on matricula . See loo samasse kausta kus on ülejäänud failid.  Selleks pakun välja 2 võimalust.

1. võimalus: Ava endale meelepärane tekstiredaktor, loo seda kasutades antud fail ning kirjuta sisse oma matriklinumber.

Vim-i juhis:

• • Käivita programm kirjutades  vim matricula . See käivitab Vim-i ja avab (vajadusel loob) sealjuures faili nimega matricula.
  • Vajuta klahvi ’i’, et minna sisestamise režiimi (insert mode).
  • Nüüd kirjuta sisse oma matriklinumber.
  • Seejärel vajuta klahvi ‘esc’, et tühistada kirjutamisrežiim.
  • Nüüd kirjuta seal aknas  :wq . w ütleb Vim’ile, et muudatused tuleb faili kirjutada ja q ütleb, et seejärel tuleb programm sulgeda. Neid saab ka eraldi kasutada.

2. võimalus: See on see, mida enamik ninapidi asjas olevad inimesed tegelikult teeksid sellise lühikese faili kirjutamiseks. Kasutusele võetaks käsk echo, mis kuvab sellele antud teksti terminaliekraanile tagasi. Echo väljundvoog (stdout) aga suunataks ümber faili, mille tulemusena vajaminev fail valmis kirjutatakse – nt echo "tekst" > fail

Samm 7: Kirjuta programm, mis väljastab “Hello  world!”

NB! Enne selle sammu teostamist meenuta mis asi on faili laiend (file extension) ning mis laiendeid kasutatakse C-programmeerimiskeele lähtekoodi failidel ning millist programmidel Linuxi keskkonnas.

Taaskord, kasuta koodi loomiseks käsurea tekstiredaktorit. Meie soovitame Vim i kuna see toetab C koodi aga sa võid kasutada ka mõnda teist tekstiredaktorit.

Kui sul on programmi kood kirjutatud, tuleb see kompileerida (meenuta, mis meie kompilaatori programmi nimi oli!). Kasuta kompilaatorile lipuna -o hello , et määrata väljundprogrammi nimeks “hello”.

Hoiatus: Ära mingil juhul kirjuta -o järele oma lähtekoodi (.c) faili nime. Sedasi kirjutad sa oma lähtekoodi üle.

Nüüd on aeg taas jooksutada meie antud testprogrammi! Kui kõik on edukalt sooritatud, loob see sulle uue faili mille sisse on kirjutatud juhised. Jälgides neid juhiseid saad ülesande esitada.

Ülesanne 2: Andmete otsimine ja veebikodu

Selle ülesande raames tutvume tööriistaga, mida kasutatakse laialdaselt oluliste andmete otsimiseks suurematest andmekogudest ning tutvustame sulle kus asub sinu veebikodu. Lisaks vaatleme ka kuidas töötab toru ehk ühe programmi standardse väljundvoo (stdout) suunamist teise programmi standardsesse sisendvoogu (stdin).

Lähteandmed

Olen genereerinud täiesti juhuslike andmetega tekstifaili, mis võiks matkida roboti poolt tekitatud logisid. Sellised failid on loomult pikad (tavaliselt olulisemalt pikemad kui minu poolt antav) ning enamasti vajame neid vaid siis, kui midagi läheb valesti. Sellisel juhul on aga vaja paljude andmete hulgast just meile vajalik info kätte saada.

Logi asub veebikodus: http://www.tud.ttu.ee/web/Risto.Heinsar/sensors.txt

Andmete filtreerimisest

Pikkade tekstifailide filtreerimiseks on väga hõlbus abiline programm nimega grep . Sellele programmile on võimalik anda parameetrina otsitav muster ning programm kuvab ekraanile ainult need read, mis sisaldavad otsitud mustrit. Ülejäänud ridu ei näidata.

Mustrid võivad olla lihtsad – näiteks ühesõnalised nagu SENSOR , ERROR , firefox jne. Sellisel juhul käivitamegi programmi kirjutades grep muster .

Mustrid võivad olla aga ka keerulisemad – need saavad koosneda regulaaravaldistest (regular expression). Regulaaravaldiste kasutamiseks lisame käivitamisel argumendi -E . Näiteks kirjutades grep -E sensor[1-3]:  leitakse meile kõik read, mis on vastavalt kas sensor1: , sensor2:  või sensor3: . Märka, et ka koolon on otsitav.

Oma regulaaravaldisi saad testida lehel: https://regex101.com

Vihje 1: Sa võid grepi väljundi uuesti greppi saata teise mustriga – kõike ei pea ühe korraga tegema kui see tundub keeruline.

Vihje 2: grep väljundi saad väljundvoo suunamise abil hõlpsasti uude faili kirjutada.

Vihje 3: Ka loogikaavaldisi saab teha – nt üks või teine otsitav muster.

Ülesande esitamine (baas- ja lisaülesanne)

1. Otsusta kas soovid lahendada baas- või edasijõudnute ülesande ning lahenda see
2. Kopeeri oma fail veebikodusse ja leia selle veebiaadress
3. Täida lahenduse kinnituseks järgmine veebivorm: https://forms.office.com/r/DcHWy2DVqk

NB! Kui sa oma veebikodu aadressi tuvastada ei suuda või tekivad tehnilised probleemid, anna meile pärast vormi täitmist märku ja näita oma faili asukohta ning aadresse mis proovisid.

Baasülesande nõuded

Sinu ülesandeks on leida üles minu antud failist kõik read, mille teabetase on viga ehk ERROR ja sensoriks on sinu matriklinumber % 10 .

Näide:

Üliõpilaskood 123456IACB, matrikkel seega 123456.
123456 % 10 on 6

Järelikult tuleb otsida kõik veaolukorrad SENSOR6 kohta. Mõned näited oodatavatest ridadest:

Ülesannet võid lahendada kirjutades kõik käsud ühele reale või tehes seda mitmes osas.

Kirjuta väljund faili, kasutades selleks väljundvoo ümbersuunamist. Loodava faili nimeks peab olema sinu üliõpilaskood.txt – näiteks kui su üliõpilaskood on 123456IACB, siis sa kirjutad tekstifaili 123456iacb.txt

Lisaülesande nõuded

Sinu ülesandeks on leida üles minu antud failist kõik read, mille teabetase on viga ehk ERROR. Ositavad read sisaldavad veateadet kas sensorilt sinu matriklinumber % 10  või mootorilt sinu matriklinumber % 4 .

Leitud read peavad jääma samasse ajalisse järjestusse nagu nad on antud sisendfailis.

Näide:

Üliõpilaskood 123456IACB, matrikkel seega 123456.
123456 % 10 on 6
123456 % 4 on 0

Järelikult tuleb otsida kõik veaolukorrad SENSOR6 või MOTOR0 kohta. Mõned näited oodatavatest ridadest:

Ülesannet võid lahendada kirjutades kõik käsud ühele reale või tehes seda mitmes osas.

Kirjuta väljund faili, kasutades selleks väljundvoo ümbersuunamist. Loodava faili nimeks peab olema sinu üliõpilaskood.txt – näiteks kui su üliõpilaskood on 123456IACB, siis sa kirjutad tekstifaili 123456iacb.txt

Veebiketta kasutamine

Kõigil üliõpilastel on oma veebiketas. Selleks on W ketas. Veebiketta kohta võid rohkem lugeda siit: https://taltech.atlassian.net/wiki/spaces/ITI/pages/38994529/li+pilase+veebikataloog+Online+student+directory

Kopeeri oma loodud fail sensorite väljundiga oma veebikettale. Kopeerimiseks kasutada cp  käsku.

Sinu fail on nüüd veebist kättesaadav ühel järgnevatest aadressidest:

• http://www.tud.ttu.ee/web/uni-id/üliõpilaskood.txt
• http://www.tud.ttu.ee/web/Eesnimi.Perenimi/üliõpilaskood.txt

Nüüd täida ära veebivorm!

Labori materjal

• Slaidid: Maatriksid

Esitamisele kuuluvad ülesanded

Selles laboris on kaks ülesannet. Teisele üelsandele on pakutud kaks lisaülesannet.

Ülesanne 1: Maatriksist tulemuste leidmine

Selle ülesande raames harjutame maatriksis nagiveerimist ja sealt tulemuste leidmist.

Ülesannet hinnatakse kolmes eraldi osas! Loe lähemalt peatükist “Hinnatavad osad” . Ülesanne tuleb ette näidata kasutades voo suunamist etteantud sisendandmete failiga.

Ülesandega alustamiseks lae alla järgnevad lähtefailid

• Aluskood: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_1_matrix.c
• Sisendfail voo suunamisega kasutamiseks: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_1_matrix.txt

Nõuded

• Ülesande jaoks on sulle antud aluskood ja tekstifail sisendiga
• Programmi jooksuta kasutades voo suunamist.
• Lisa programmi algse maatriksi väljatrükk. Väljatrükk peab olema joondatud samamoodi nagu näidisel.
• Leia järgnevad tulemused
  • Peadiagonaalil olevate negatiivsete arvude summa
  • Kõrvaldiagonaali kohal (kõrvaldiagonaalist kõrgemal) olevate positiivsete arvude korrutis
  • Iga rea suurim arv
• Kõik väärtused tuleb salvestada täisarvulistesse andmetüüpidesse.  Andmetüübid nagu float, double jne ei ole lubatud.
• Kui soovid kasutada väiksemaid või suuremaid andmetüüpe kui 32-bitised, peavad need olema määratud täpselt (nt inttypes.h  teegi abil). Tüübid nagu long  ja long long  ei ole lubatud
• Lahendus peab olema ühilduv erinevatel platvormidel. Formaadid nagu %ld  ja %lld  ei ole lubatud
• Ülesande raames tuleb sul luua nõutud funktsioonid. Loetelu nendest on kirjeldatud järgnevas punktis.

Nõutud funktsioonid

Programmi tuleb lisada kokku 5 funktsiooni. Vajadusel võid neid lisada täiendavalt juurde.

• Maatriksi lugemine. Funktsiooni töö käigus loetakse maatriks mällu. Tagastust ei ole. Funktsioon on lahendatud sinu eest aluskoodis.
• Maatriksi väljatrükk. Funktsiooni käigus trükitakse maatriks ekraanile samamoodi nagu näidisel. Tagastust ei ole. Funktsiooni prototüüp antud aluskoodis.
• Peadiagonaalil olevate negatiivsete arvude summa. Funktsioon tagastab summa main()  funktsiooni, kus see välja trükitakse. Kõrvalmõjud on keelatud! Funktsiooni prototüüp antud aluskoodis.
  NB! Ettevaatust liiasusega! Vaata millistel indeksitel arvud asuvad ning sea tsükliloendurid täpselt nendele positsioonidele. Käia läbi 49-kohaline maatriks ainult 7 arvu leidmiseks ei ole okei. Kujuta ette kui nt tegu oleks 1000 x 1000 maatriksiga – sellisel juhul käiksid läbi miljon arvu selleks, et leida vaid nendest tuhat. Kogu tööst oleks kasulik sellisel juhul vaid 0.1% (väheneb eksponentsiaalselt)
• Kõrvaldiagonaali kohal (kõrvaldiagonaalist kõrgemal) paiknevate positiivsete arvude korrutis. Funktsioon tagastab korrutise main() funktsiooni, kus see välja trükitakse. Kõrvalmõju ei ole.
• Rea-kaupa suurimate arvude leidmine. Disain on sinu enda otsustada. Kõrvalmõjud on lubatud, tulemused võib printida soovi korral funktsiooni sees. Võid lisada ka mõne täiendava abifunktsiooni.

Hinnatavad osad

Sellel ülesandel on 3 hindamiskohta, vastavalt pärast iga tulemuse edukat leidmist.

Kohustuslik, olenemata millist alamosa näitad:

1. Programmi tuleb jooksutada kasutades voo suunamist
2. Sisestatud maatriksi väljatrükk

Eraldi hinnatavad alamosad:

• Osa 1: Peadiagonaalil olevate negatiivsete arvude summa.
• Osa 2: Kõrvaldiagonaali kohal (kõrvaldiagonaalist kõrgemal) olevate positiivsete arvude korrutis.
• Osa 3: Iga rea suurim arv.

Vihjeid

• Vaata kuidas ReadMatrix()  funktsioon on kirjutatud. Sedasi saad ka oma ülejäänud funktsioonide parameetrid kujundada.
• Väljatrükk: Jällegi, vaata funktsiooni ReadMatrix(). Tsüklite struktuur on juba tehtud selliselt, et see käib läbi kõik maatriksi positsioonis. Peaksid lugemise asendama väljastusega. Reavahetuseks mõtle mis eesmärki omab sisemine tsükkel ja mis eesmärki välimine (ning kus paikned maatriksi suhtes enne ja pärast välimist tsükli töötamist ning kus asud enne ja pärast sisemise tsükli töötamist).
• Osa 1: Kirjuta endale välja maatriksi liikmete indeksid, mida sul on vaja summeerida. Vaadates nende indeksite väärtusi mõtle mitut erinevat muutujat nende jaoks on vaja (ning samaaegselt ka tsüklit).
• Osa 2: Meenuta mis juhtus täisarvu ületäitumisel.
• Osa 3: Maatriksi ühte rida on võimalik edastada funktsiooni. Selleks määrame ära soovitud reaindeksi ning anname kaasa ka rea pikkuse. Nii saad korduvkasutada juba varasemas laboris valmis tehtud funktsiooni. Nt FindMaxValue(matrix[rowIndex], rowLength)

Testimine

Võrdle oma tulemust allolevaga nende õigsuses veendumiseks!

Ülesanne 2: Kinosaal

Meile on antud kinosaali plaan, mis on kujutatud 2-dimensioonilise maatriksina. Sinu peamiseks ülesandeks on väärtuste tõlgendamine antud maatriksist.

Kõik istekohad on kodeeritud järgnevate täisarvuliste numbritega:

• 0 – istekoht puudub
• 1 – istekoht on vaba
• 2 – istekoht on hõivatud

Maatriksis positsioonil (0, 0) asub saali ülemine vasak istekoht.

Lae alla kinosaali algväärtustatud maatriks: https://blue.pri.ee/ttu/files/iax0583/aluskoodid/9_2_cinema_init.c

Nõuded

• Kuva saali plaan. Programmi väljund peab olema samasugune nagu etteantud näidistel, sh
  • Vasakul ääres on rea numbrid.
  • Kõik read algavad esimesest istekohast, kuid arvestada tuleb, et saal on eest kitsenev (vt näide)
  • Ekraani asukoht on näidatud
  • Vabad istekohad kuvatakse numbritena
  • Hõivatud istekohad kuvatakse suure X tähena
  • Puuduvaid istekohti ei kuvata
• Küsi kasutajalt soovitud istekoht ning väljasta kas koht eksisteerib, on vaba või mitte.
• Minimaalselt loo 2 funktsiooni peale main funktsiooni. Üks saaliplaani kuvamiseks, teine istekoha saadavuse kontrolliks. Võid julgelt ka rohkem funktsioone luua.

Töövoo soovitus

1. Prindi saaliplaan tavalise maatriksina. Ära veel väljundit kohandama hakka.  Veendu, et saad numbrid kätte ja vormindatud.
2. Nüüd hakka väljundit kohandama (tõlgendama maatriksis olevaid väärtusi korrektselt). Loo tingimuslause, mille abiga tuvastada kui koht maatriksis puudub ja väljasta “tühjus” seal oleva numbri asemel.
3. Seejärel jätka teiste kodeeritud väärtuste tõlgendamist ja visuaali loomist.
4. Kui saaliplaan on valmis, prindi saaliplaani kõrvale rea numbrid.
5. Küsi kasutajalt tema soovitud istekoha asukoht.  Kontrolli, et väärtused oleksid “mõistusepärased” (nn sanity check).
6. Rea numbri maatriksis saad välja arvutada koheselt. Tulba numbri leidmiseks pead arvestama ka puuduvate istekohtadega.
7. Väljasta maatriksis leitud indeksid veendumaks, et leidsid õige asukoha!
8. Nüüd lõpeta ülejäänud programm.

Vihjeid

• Saali plaan on peegeldatud kujul võrreldes massiivi tegelike indeksitega. Abiks võib olla kui joonistad endale välja ja märgid ära esimese ja viimase rea asukohad.
  • Rida 14 asub massiivis indeksiga 0
  • Rida 1 asub massiivis indeksiga 13
  • Istekoha kontrollis trüki välja massiivi indeksite väärtused (pildil rida algusega DEBUG)
• Kasuta istekohtade loendamiseks eraldi loendurit.
• Sellist kodeeritud täisarvu on hea lahendada kasutades switch()  lauset.

Programmi testimine ja näide

NB! Näidistel on kasutatud ka värve, seda sinu lahenduses olema ei pea (kuid võib 🙂 )

Näidises on samuti lisatud silumiseks DEBUG rida, kus kuvatakse massiivi asukoht kust istekohta otsiti. Sedasi on lihtsam oma programmi õigsust kontrollida.

Lisaülesanne 1: mitu piletit

Lisame võimaluse kasutajal osta mitu piletit korraga.

• Kasutaja saab sisestada soovitud piletite arvu
• Kõik istekohad peavad paiknema kõrvuti, samas reas
• Lähtepunktiks on kasutaja sisestatud istekoht. Täiendavad kohad võivad paikneda sellest nii vasakul kui paremal pool (sh mõlemal pool korraga).
• Kuva kasutajale pakutavad istekohad.

Lisaülesanne 2: ostukinnitus

Lisame kasutajale võimaluse ümber mõelda oma piletiostu soovi.

• Selle ülesande eelduseks on esimese lisaülesande lahendus.
• Pärast istekohtade pakkumist tuleb kasutajalt küsida kinnitust kas ta soovib pakutavaid istekohti.
• Kui kasutaja keeldub pakutavatest kohtadest või ei olnud võimalik soovitud asukohas istekohti pakkuda kuvatakse kasutajale uuesti saali plaan ning pakutakse talle võimalust uuesti istekohti valida

Vihje: Algses maatriksis on pakutud välja 3 kodeeritud väärtust. Võid neid soovi korral lisada. Alternatiivina saad teha algsest maatriksist koopia.

Programmi näide

Näide on koostatud pärast mõlema lisaülesande lahendamist.

Pärast tundi peaksid oskama järgmist

• Peaksid oskama erineva pikkusega arve kasutama koodis, sh 64-bitist täisarvu.
• Mõistma mis hetkel täisarvu ületäitumised juhtuvad koodis
• Olema suuteline visualiseerima kahedimensioonilist massiivi (maatriksit)
• Suutma deklareerida ja indekseerida kahedimensioonilist massiivi
• Suutma indekseerida kindlaid osi kahedimensioonilisest massiivist (nt esimene või viimane rida, kolm esimest rida, teine element kolmandast reast jne)
• Mõistma ja olema suuteline kasutama maatriksi diagonaalide omadusi
• Suutma käia maatriksit läbi nii rida-rea haaval kui ka veerg-veeru haaval.

Täiendavat materjali

• http://www.cplusplus.com/reference/climits/
• http://www.cplusplus.com/reference/cinttypes/
• http://www.cplusplus.com/reference/cstdint/
• Adding Color to Your Output From C
  https://www.theurbanpenguin.com/4184-2/