Ryhmässä tekeminen

Mikäli teette tehtäviä ryhmässä, niin kirjautukaa kaikki TIMiin, niin saatte palautettua tehtävät kerralla kaikille ryhmäläisille. Ryhmän muiden jäsenten kirjautumisen voi tehdä yläreunassa olevaa omaa nimeä klikkaamalla; sieltä aukeaa valikko, jossa voi lisätä muita käyttäjiä. Lopuksi muistakaa kaikki kirjautua ulos.

Demoista yleistä

Demoista yleisesti sekä niiden pisteistä ja miten niitä lasketaan, kerrotaan tarkemmin kurssin Demot-sivulla

Demot palautetaan viimeistään maanantaina klo 11:00 mennessä. Voit palauttaa osan tai kaikki tehtäväsi etukäteenkin ja täydentää vastauksia määräaikaan mennessä.

Demotehtävän alussa tai muualla iso M ja linkki tarkoittaa viittausta luentomonisteeseen. Linkki menee TIM-monisteeseen, mutta käynnistää joka kerta siitä uuden "esiintymän". Jos haluat säästää aikaa, katso M-kirjaimen jälkeen oleva otsikko ja etsi aina 1. kerran avatusta TIM-monisteesta vastaava otsikko (Ctrl-F) ja siirry siellä siihen kohtaan. Tai siirry M-linkin kohdalle, hiiren oikealla paina "Kopioi linkin osoite" ja mene kerran avattuun TIM-monisteen sivulle ja liimaa kopioitu linkki osoiteriville. Tämän pitäisi siirtyä oikeaan kohtaan lataamatta monistetta uudelleen.

Jokaisessa demossa on vähintää kaksi tähtitehtävää (*). Tähtitehtävistä vähintään kaksi pitää tehdä joka kerta ja saada niistä yhteensä 2 pistettä. Eli tekemiseen ei riitä että niihin jättää "väärän" vastauksen.

Kurssin pystyy suorittamaan arvolauseella 1/5 ilman tenttiä, mikäli joka kerta on vähintään 5 pistettä demoista (joista 2 pitää olla tähtitehtävistä).

Tehtävien pisteistä

Jokaisella tehtäväkerralla voi olla tavallisia tehtäviä, Ville-tehtäviä (V=Ville) Tauno-tehtäviä (T=Tauno), lisätehtäviä (B=Bonus) ja harrastajien tehtäviä (G=Guru).

Tehtävät ovat yhden pisteen tehtäviä, ellei ole erikseen mainittu, että tehtävästä saa useamman pisteen (esim. Ville 1, Tehtävä 1 ja B2 eli Bonus 2 ovat maksimissaan yhden pisteen tehtäviä, mutta G1-2 on maksimissaan kahden pisteen tehtävä).

Viikkotuntimäärän antamisesta saa 0.25 pistettä.

Kun olet tehnyt tehtävän, muista tarkistaa, että pistemäärä on oikein. Viimeisimmän ajon/testin pisteet jäävät voimaan. Test-napin sisältävät tehtävät tuottavat usein eri määrän pisteitä ajamisesta ja testaamisesta.

Esimerkki:

Ajaminen onnistuu   ->  0.5p
Testit menevät läpi ->  1p

Jos edeltävässä esimerkissä menisi vielä testin jälkeen painamaan aja-nappia, niin pisteet alenisivat 0.5p ja täysiin pisteisiin täytyisi siis painaa Test-nappia uudelleen.

Likikään kaikissa tehtävissä ei ole (eikä voi olla) automaattista arvostelua ja osan niistä pitää itse antaa omantunnon mukaan pisteet.

Prosentteja laskettaessa enimmäispisteet demokertaa kohti on tavallisten tehtävien lukumäärä (6 vaikka niitä olisikin enemmän). Siten Ville/bonus/GURU-tehtävillä voi "kerätä pisteitä varastoon". GURU-tehtävien tarkoitus on myös tarjota asiaa jo osaaville hieman haastavampia tehtäviä. Kuitenkin kultakin demokerralta lasketaan max. 8 p. Eli vaikka merkitsisi enemmän kuin 8 pistettä, siirtyy automaattisesti korkeintaan 8 pistettä Korppiin.

Vanhat vastaukset tai kavereiden vastaukset

Tehtävistä saattaa liikkua edellisten vuosien vastauksia ja jos niiden tai kavereiden vastauksien käyttämisestä jää kiinni, ovat rangaistukset lunttaamiseen verrattavia! Tärkeintä kurssilla on OPPI­MINEN, ei demopisteiden kalastelu tai kopiointi. Kopiot saa jo demoissa valmiiksi painetussa muo­dossa.

Ryhmätyö on sallittua, mutta tämä ilmaistaan laittamalla aina tiedoksi - esimerkiksi ohjelman kommentteihin - kaikkien ryhmään osallistuneiden nimet.

Taunon käyttöohjeita:

Kunkin Tauno-tehtävän aluksi klikkaa Click here to show Tauno -linkkiä.

Taunossa raahaa taulukon alkioita niin, että sinulla on lopuksi tehtävässä pyydetty lopputulos. Katso samalla minkälaista koodia Tauno sinulle generoi. Tämä on C#-kielinen algoritmi tehtävän suorittamiseksi. Jos haluat aloittaa Tauno-tehtävän alusta, piilota ja näytä Tauno uudelleen.

Raahaamisen sijaan (ja joissakin mobiileissa ei muuten voi tehdäkkään) voit myös tökätä ensin lähdealkiota ja sitten kohdealkiota.

Jos tarvitset apumuuttujia, joihin voit viedä alkioita tilapäiseen "säilöön", paina uusi muuttuja-painiketta. Keksi muuttujalle kuvaava nimi. Muuttujalle voit antaa alkuarvon, mutta tämä ei ole pakollista jos olet heti aikeissa raahata siihen jonkin toisen muuttujan arvon talteen.

Laskutoimituksia voit tehdä raahaamalla arvoja vasemmassa alakulmassa olevaan laskualueeseen ja valitsemalla arvojen välistä minkä laskutoimituksen haluat tehdä. Laskun tuloksen voit sitten raahata takaisin johonkin muuttujaan (siis myös taulukon alkioksi).

Muuttujan arvoa voit lisätä/vähentää yhdellä vetämällä ++ tai -- -operaattorin muuttujan arvon päälle.

Kun olet saanut Taunolla ohjelman mielestäsi valmiiksi, voit painaa Aja tai Test -painikkeita nähdäksesi miten ohjelma toimii. Molemmissa tapauksissa Taunon tekemä ohjelmakoodi kopioidaan ohjelma-alueeseen ja ajetaan. Ajossa voidaan käyttää eri taulukkoakin kuin mitä Taunossa käytettiin, mutta hyvä "algoritmi" selviää tästäkin. Jos testissä saat punaista, lue huolella virheilmoitus ja mieti mikä meni pieleen. Täysiä pisteitä varten sekä Aja että Test pitää toimia.

Halutessasi voit aloittaa Taunolla alusta tai sitten jos osaat, voit korjata suoraan ohjelma-alueeseen kopioitua koodia. Demotehtävän vastaukseksi riittää että Aja-napin yläpuolella on sama koodi kuin Taunon koodialueessa.

Näytä koko koodi-linkistä voit katsoa minkälaisilla arvoilla ohjelma ajetaan tai minkälaisilla arvoilla testataan. Tästä kokonaisuudesta ei kurssin aluksi tarvitse vielä ymmärtää kaikkea. Voit tietysti yrittää "arvailla" mistä on kyse.

Tehtävä Tauno T1 a

Tee Taunolla ohjelma, joka kääntää taulukon päinvastaiseen järjestykseen.

Tehtävä Tauno T1 b

Tee Taunolla ohjelma, joka vaihtaa joka toisen alkion pareittain keskenään. Eli taulukosta 1, 2, 3, 4 tulee taulukko 2, 1, 4, 3

Tehtävä Ville V1

Tee Villestä kohta 1.

Tee myös Villestä tehtävä 2.1. Palauta tehtävä kirjoittamalla alla olevaan tekstilaatikkoon mitä opit ja mitä mieltä olit kerran Ville-tehtävistä ja auttoivatko Ville-tehtävät sinua yhtään. Muutama rivi riittää.

Kun kirjoitat TEKSTIvastauksia, niin rivitä vastaus itse niin että se näkyy kunnolla vastausruudussa. Toisaalta tekstikäsittelyssä (esim. Word) ei saa itse rivittää.

Tehtävä 1. Komentorivi / PowerShell

Tehtävän saa tehdä myös Macillä tai linuxilla.

• luennolla jaettu listaus komentorivin komennoista eri järjestelmissä.

Tee PowerShelliä käyttäen tietokoneellesi (tai Agoran mikroluokassa U:-asemallesi) alla olevan mallin mukainen hakemistorakenne kurssin demovastauksia varten. Alla sisennykset kuvaavat sitä, mikä on minkäkin alihakemisto.

Mikäli teet cmd-komentokehotteessa, Linuxilla tai Macillä, niin lue vastaavien komentojen versiot komentoriviohjeesta.

Huom. Tulevissa Windows PowerShell-komennoissa oletetaan, että kurssit-hakemisto on luotu aseman juureen, esim. U:\kurssit. Jos luot sen muualle, esim. paikkaan C:\jutut\kurssit, niin korvaa komennoissa polku U:\kurssit polulla C:\jutut\kurssit.

kurssit
  ohj1
    demot 
      demo1
      demo2
    ht

Kun olet luonut yllä olevan hakemistorakenteen, kirjoita komento

dir -s U:\kurssit (tai Linuxissa: ls -R HAKEMISTO)

Pitäisi näkyä mm. seuraavia rivejä, jos tehtävä on tehty oikein (Linuxissa ja komentorivissä näyttää vähän erilaiselle, mutta idea on sama):

    Directory: U:\kurssit

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----         1.9.2017     16.16                ohj1

    Directory: U:\kurssit\ohj1

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----         1.9.2017     16.16                demot
d-----         1.9.2017     16.22                ht

    Directory: U:\kurssit\ohj1\demot

Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----         1.9.2017     16.16                demo1
d-----         1.9.2017     16.16                demo2

Tehtävän vastaukseksi luodaan palautettava tiedosto teht1.txt seuraavasti:

cd \kurssit\ohj1\demot\demo1
dir -s U:\kurssit > teht1.txt (Linuxissa ls -R ~/kurssit > teht1.txt)

Katso, mitä tuli tiedostoon teht1.txt:

type teht1.txt (Linuxissa cat teht1.txt)

tai voit katsoa teht1.txt tiedoston sisältöä myös jollakin tekstieditorilla (esim. Notepad++, Sublime Text).

Kopioi tiedoston teht1.txt sisältö alla olevaan tekstikenttään

Tehtävä 2. Tiedoston kirjoittaminen

Editorin käyttötaito: Ota sekuntikellolla aika, kauanko juuri sinulla menee alla olevien ohjeiden mukaisen tekstitiedoston kirjoittamiseen. Ei saa huijata! Tämä on leikkimielinen mutta sitäkin vakavampi kilpailu.

Lue ensin tehtävä huolellisesti. Kun olet ensin sisäistänyt kaikki ohjeet, aloita tyhjästä tiedostosta ja käytä ainoastaan valitsemaasi tekstieditoria ja omia käsiäsi. (Tekstieditori on esimerkiksi ConTEXT, NotePad++, SublimeText, VIM, Emacs tms. Mikään Word tai muu "Office"-tyyppinen ohjelma ei ole tekstieditori). Kaikki editorin ominaisuudet ovat tietysti käytössä (eli leikkaa-liimaa, etsi-ja-muokkaa ja vastaavat kumppanit). Hiirtä EI SAA käyttää lainkaan tehtävän aikana. Aloita ajanotto siitä, kun kirjoitat ensimmäisen merkin, ja lopeta siihen kun viimeinen merkki on kirjoitettu. Tiedoston sisällön tulee olla seuraavanlainen:

1. Aluksi tasan sata riviä, joilla jokaisella lukee:

   Harjoittelen tekstitiedoston tekemistä!

2. Sen jälkeen tasan yksi rivi, jossa on tasan 80 kpl miinusmerkkejä '-' eikä mitään muuta, ei myöskään välilyöntejä.

3. Sitten neljäkymmentä riviä, joissa on luvut ykkösestä neljäänkymmeneen kahdella numerolla siten, että jokaisella rivillä on yksi luku. Näin siis alkaisi tämä pätkä:

   01
   02
   03

   ...ja näin päättyisi:

   39
   40

4. Loppuun taas sellainen rivi, jossa on tasan 80 kpl miinusmerkkejä. Mitään muita rivejä tai tyhjiä rivejä ei saa olla. Tyhjiä merkkejä ei saa olla rivien aluissa tai lopuissa.

Pysäytä ajanotto. Tallenna nimelle teht2.txt. Jälkeenpäin kirjoita vielä tiedoston loppuun (uudeksi viimeiseksi riviksi heti miinusmerkkirivin perään), kauanko sinulta meni. Ajan tulee olla muotoa mm:ss, missä mm on minuuttien määrä ja ss on sekuntien määrä. Tämän perään uudelta riviltä aloittaen kirjoita vielä lyhyt kuvaus siitä, mitä ja miten teit tehtävän aikana. Tässä on vastaustiedostosi tähän tehtävään. Tulos antaa itsellesi suuntaa nykyisestä tehokkuudestasi tekstin tuottajana suhteessa kurssikavereihin. Esim. Ohjelmointi 1 -kurssin lopussa voi tehdä testin uudelleen, ja kokeilla onko tapahtunut kehitystä.

Kopioi kirjoittamasi tiedoston sisältö alla olevaan vastausalueeseen ja ole todella huolellinen että kaikki on kuten ohjeissa. Muuten ei anna 1p. Virheitä voi olla mm:

• rivien lopuissa ylimääräisiä välilyöntejä
• viivariveillä ei ole täsmälleen 80 miinumerkkiä
• aika on muotoa 3:45 eikä 03:45
• aika-rivillä on jotakin muutakin kuin pelkkä aika
• aika rivin jälkeen ei ole rivinvaihtoa
• puuttuu aika-rivin jälkeen selitys siitä, miten toimittiin.

Tehtävä 3. Työkalut

Varmista, että sinulla on jossakin käytössäsi minimityökalut tämän kurssin suorittamiseen. Omaa konetta varten työkalujen latauslinkit ja asennusohjeet löydät kurssin TIMistä. Agoran mikroluokissa Mountains 212.2 ja Lakes 213.1 nämä löytyvät valmiina

• Tekstieditori
• Microsoft Visual Studio 2017 Community Edition (tai Ultimate jos haluat)
• MonoGame
• Jypeli-kirjasto (tulee em. ohjeilla)
• Jypeli-projektimallit Visual Studioon (tulee em. ohjeilla)
• Komentotulkki (aina valmiina koneessa)
• Internet-yhteys ja SSH-pääteyhteysohjelma (esim. PuTTY tai vastaava)
• TortoiseSVN harjoitustyötä varten

Jos ohjelmien asennuksessa ilmenee ongelmia, voit kysyä neuvoa kaverilta, katsoa kurssin wiki-sivuilta löytyviä asennusohjeita tai kysyä postilistalla ohj1s18k@korppi.jyu.fi. Kotoa käsin toimiminen edellyttää pidemmän päälle edellä mainittujen työkalujen asentamista! Ihan alkuun voi hätätilassa tulla toimeen pelkästään tekstieditorilla.

Kokeile käytännössä (M: 2. Ensimmäinen C#-ohjelma):

• Tallenna esimerkkiohjelma HelloWorld.cs netistä demohakemistoosi.

• Kopioi kyseinen tiedosto hakemistoon C:\mytemp\OMATUNNUS\ohj1\demo1.

  • Siirry C:\mytemp\OMATUNNUS\ohj1\demo1 hakemistoon.
  • Toistaiseksi mikroluokissa voi ohjelmia ajaa vain hakemistossa C:\mytemp. Siksi tämä kopiointi.
  • Aikanaan kun tehtävä(t) tulevat valmiiksi, kopioi .cs -tiedostot takaisin U-levylle.

• PowerShelliä tai komentotulkkia (cmd) käyttäen käännä ohjelma ja aja se. Pikaohjeet löytyvät kurssin TIMistä. Tässä lyhyesti (muista että csc hakemisto voi olla eri):

• Komentotulkki:

  path=c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\Roslyn;%path% 
  
  csc HelloWorld.cs
  HelloWorld.exe

• PowerShell

    $env:Path += ";c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\MSBuild\15.0\Bin\Roslyn"
  
    csc HelloWorld.cs
    .\HelloWorld.exe

Tehtävän vastauksena lisää tiedostoon HelloWorld.cs oma nimesi (tai kaikkien ryhmän jäsenten nimet) kommentteihin. Kopioi tiedoston HelloWorld.cs sisältö alla olevaan tekstikenttään. Dokumentoinnin osalta ota mallia esimerkistä: 2.4.1 Dokumentointi.

Tehtävä 4. ASCII-koodi

Tämä tehtävä on tarkoitus tehdä ilman minkään apuohjelman käyttöä. Tehtävän tekemiseksi tehtävän taulukko 3 ja luentomonisteen Taulukko 10 riittää lähteeksi.

M: 27. ASCII-koodi: Voi voi. Simolta on mennyt USB-tikku rikki. Tikulla on vain pieniä tiedonsirpaleita eikä mitään tietoa, mikä sirpale kuuluu mihinkin. Siellä oli paljon MP3-tiedostoja ja kaikkea turhaa... Simo tietää, että yhdessä elintärkeässä tiedostossa hänellä luki selväkielinen teksti isoilla kirjaimilla. Alla oleva bittijono näyttää lupaavalta, mutta mikä teksti siihen on tallennettu:

Taulukko 1:
01010100  01010101  01010100  01001011
01001001  01000101  01001100  01001101
01010011

Helpotetaan: seuraavassa on samat (taulukon 1) tavun mittaiset jonot 10-järjestelmän lukuina (saatu luettua taulukosta 3 eli 01010100 = 84 jne...), ja malliksi on yksi luku muutettu ymmärrettäväksi kirjaimeksi alla olevaan taulukko 2:een.

Taulukko 2:

binääri   dec   char  hex
==========================
01010100 = 84
01010101 = 85 => U     55  
01010100 = 84
01001011 = 75 

... täydennä vastaavuudet loppuun saakka ...
    heksadesimaali (hex) arvo täydennetään tehtävän lopussa, 
    kun olet ensin tehnyt tämän alkuosan

Tulkitse kaikki muutkin merkit, ja vastaa sitten seuraaviin kysymyksiin:

• Mikä teksti tuohon kohtaan USB-tikun muistia on tallentunut?
• Montako millimetriä Simo on painanut ohi yhdestä näppäimestä? Hänellä on samanlainen näppäimistö kuin sinulla.
• Mikä binääriluku pitäisi olla viallisen kirjaimen kohdalla?

Tehtävän vastauksena kirjoita täydennetty taulukko 2 kirjainten vastaavuuksista ja vastaukset kysymyksiin. Simo tietää, että hänen käyttämässään tiedostomuodossa merkeille on sovittu seuraavat koodit (pala ASCII-koodia):

Taulukko 3:

Desimaaliluku Binäärilukuna Vastaa merkkiä
-------------------------------------------
  32          00100000      [välilyönti]
  33          00100001        !
  46          00101110        .
  65          01000001        A
  66          01000010        B
  67          01000011        C
  68          01000100        D
  69          01000101        E
  70          01000110        F
  71          01000111        G
  72          01001000        H
  73          01001001        I
  74          01001010        J
  75          01001011        K
  76          01001100        L
  77          01001101        M
  78          01001110        N
  79          01001111        O
  80          01010000        P
  81          01010001        Q
  82          01010010        R
  83          01010011        S
  84          01010100        T
  85          01010101        U
  86          01010110        V
  87          01010111        W
  88          01011000        X
  89          01011001        Y
  90          01011010        Z

Kun olet tulkinnut kaikki merkit muunna binääriluvut heksaluvuiksi jollakin seuraavista tavoista (tai kokeile useampia):

1. avaa Windowsin tms. laskin ja laita se Programmer tilaan ja katso kutakin 10-järjestelmän lukua vastaava heksaluku (esim 85 kymmenjärjestelmässä on 55 heksalukuna)
2. ota kurssin kotisivun ohjeiden mukaan itsellesi jokin heksa-editori. Kirjoita esim. NotePad++:lla tai vastaavalla tiedosto (vaikka nimelle t4.txt), jossa on äsken katsomasi teksti tekstinä (siis ne tulkitsemasi merkit). Sitten avaa tämä tiedosto heksaeditorilla ja katso vastaavien merkkien arvot heksalukuina.
3. avaa luentomonisteesta muunnostaulukko ja muunna binäärilukuja heksaluvuiksi seuraavalla tavalla:
   1. jaa binääriluku 4 bitin palasiin
   2. katso kumpaakin palasta vastaava 16-järjestelmän (heksajärjestelmän) luku taulukosta
   3. heksaluku on kun nämä luvut laitetaan peräkkäin
   Esimerkiksi binääriluku 01011010 = 0101 1010 ja muunnostaulukosta vastaavat heksaluvut ovat 5 ja A eli binääriluku on heksalukuna 5A.
4. katso kutakin kirjainta vastaava heksaluku monisteen ASCII-taulukosta.

Kirjoita heksaluvut vastaustaulukkoon kunkin kirjaimen vierelle (kuten mallipohjassa on tehty U:n kohdalle. Yleensä tietotekniikassa käytetään heksalukuja silloin, kun halutaan puhua binäärisistä arvoista koostuvista kokonaisuuksista (kuten tässä esimerkissä kirjainten koodeista).

Tehtävä 5*. Tietojen tulostaminen

M: 2. Ensimmäinen C#-ohjelma: Kopioi aluksi tehtävän 3 tiedosto HelloWorld.cs tiedostoksi Mina.cs:

copy HelloWorld.cs Mina.cs

Avaa Mina.cs editoriin (komentoriviltä esim. komennolla npp Mina.cs). Jos komento ei toimi, varmista että olet liittänyt N-levyn täältä. Muuta luokan nimi HelloWorld nimeksi Mina. Sitten muuta ohjelma sellaiseksi, että se tulostaa sinun nimesi, kännykkäsi valmistajan ja operaattorisi nimen, kunkin eri riveille. Käännä ja aja ohjelma. Kopioi tiedoston Mina.cs sisältö alla olevaan tekstikenttään. Muista dokumentointi.

(Huom: Yliopiston koneilla U-asemalta ei saa ajaa ohjelmia. Käytä C:\MyTemp-kansiota.)

Tehtävä 6*. Lumiukko

M: 4. Yksinkertainen graafinen C#-ohjelma: Muuta ohjelma sellaiseksi, että se piirtää lumiukolle silmät, mielellään myös nenän ja suun.

Tehtävän voi tehdä (ja kannattaa tehdä) myös työasemassa pääteohjaus 1:n Lumiukko ohjeilla. Jos teet työasemassa, niin kopioi demonpalautukseen silti ohjelmasta se osa, joka on Begin-aliohjelman sulkujen { } välissä (koska muu osa on alla olevassa koodissa jo valmiina, ks. Näytä koko koodi.

Tehtävä 7. TIMiin tutustuminen

7 a)

Jokaisen kurssin sivun yläpalkissa on lista joka alkaa Koti 2018s ja loppuu keskustelu. Käy jokaisella sivulla ja kirjoita alle kustakin n. 1-2 rivin mittainen kuvaus siitä, mitä sivulla on. Huomaa käydä myös sivulla Demot. Sen perässä on kukin demokerta numerona, niistä riittää käydä tämä kerta.

7 b)

Seuraavissa tehtävissä kopioi osoitepalkissa oleva sivun/sivujen osoite/osoitteet kunkin tehtävän vastaukseksi. Sivuilla tarkoitetaan Ohj1-kurssin TIM-sivuja, eii Googlella löydettyjä satunnaisia sivuja. Vastauksiin ei myöskään laiteta sivuja, joiden osoitteessa esiintyy jokin tietyn kurssin aika tyyliin 16k3op tai 2017s. Paitsi jos erkiseen kysytään jonkin tietyn vuoden sivua.

7 c)

Kun tehtävässä 6 klikkailet linkkiä Tavallinen/Highlight mitä tapahtuu? Kun klikkailet linkkiä Näytä koko koodi, mitä tapahtuu?

B1. Alice

Ota ja asenna Alice ohjeiden mukaan. Alice 2:n tapauksessa käy ensimmäinen (luistelu) tutoriaali läpi. Jos käytät Alice 3:sta, tee "ohjelma", jossa on muutamia otuksia, jotka tekevät jotakin. Vastauksena kirjoita parilla rivillä mitä opit ja miltä Alice tuntui, kannattaako siitä ottaa jatkossa lisäesimerkkejä. (ks video)

B2. Numeron siirtäminen

Yhtä numeroa (ei lukua, 62 on luku) siirtämällä tee yhtälöstä 62 - 63 = 1 tosi. Siirtäminen tarkoittaa sitä, että kuvitellaan annetussa kaavassa olevan 7 merkkiä (5 numeroa ja - ja =). Jos nuo merkit olisivat vierekkäisiä paperilappuja, niin tasan yhtä numeroa saa siirtää ja muihin ei saa koskea.

B3. Kurssin alkukysely

Vastaa kurssin alkukyselyyn.

Sitten kirjoita kurssin QA-sivulle halumasi otsikon alle jokin kysymys, jonka haluaisit esittää luennoitsijalle. Parhaisiin vastataan luennoilla. Tehtävän vastaukseksi kopioi kysymystekstisi tähän alle. Jos teit tämän jo demossa 0, niin kopioi sieltä kysymyksesi tähän.

Tehtävä G1-2. Luvut joiden neliöjuuri on kokonaisluku

Tee C#-ohjelma, joka tulostaa kaikki ne kokonaisluvut <= 1000, joiden neliöjuuri on kokonaisluku. Kukin luku tulostetaan omalle rivilleen. TDD: Kirjoita ennen koodaamista käsin lukuja ja niiden neliöjuuria.

Tauno T1 a

Lisää tulos-niminen muuttuja Taunoon. Tee ohjelma, joka laskee yhteen taulukon luvut niin, että lukujen summa on lopuksi tulos-nimisessä muuttujassa.

(Muista painaa Taunoissa sekä Aja että Test että saat niistä kummastakin Taunosta sen 0.5 pistettä eli molemmista Taunoista yhteensä 1 p.)

Tauno T1 b

Lisää tulos-niminen muuttuja Taunoon. Tee ohjelma, joka laskee yhteen taulukon luvut niin, että parillisissa paikoissa olevien lukujen summa on lopuksi tulos-nimisessä muuttujassa.

Ville V1

Tee Villestä tehtävät 2.2-2.6 ja 6.1-6.4.

Kerro tehtävän palautuksen mitä opit Villeltä.

Vinkki: Muodollinen parametri on "turkulaisten kielessä" aliohjelman esittelyssä oleva muuttujan nimi ja todellinen parametri sille kutsussa sijoitettu arvo (C#-dokuissa tämä on argument).

Tehtävä 1. Lausekkeiden arvot

Mieti ensin kustakin alakohdasta, että mitä ohjelma tekee. Kirjoita päätelmäsi ylös ja kokeile vasta sitten itse ohjelmaa (joka pitää korjata oikeaksi että sen voi ajaa). Ohjelmakoodin lukeminen on tärkeä taito. Voit myös kokeilla tehdä ohjelmat itse Visual Studiolla. Kohtien a)-d) ohjelmien ajamisesta ei tule pisteitä, vaan niihin kuuluvien kysymysten vastauksista, kustakin alakohdasta max 0.25 p. Lue ensin huolella mitä kysytään ja miten pitää vastata.

a) Olkoon meillä seuraavanlainen pääohjelma:

Mitä viimeinen rivi (ennen aaltosulkua) tulostaa? Kirjoita yhdelle riville se luku minkä ohjelma mielestäsi tulostaa. Kun olet tallentanut vastauksesi voit täydentää luokan (class, ks. alkuperäinen HelloWorld -ohjelma) yllä olevan koodin ympärille ja tarkistaa vastauksesi painamalla aja-nappia.

b) Miten tuloste muuttuisi, jos kaikki sulut otettaisiin pois riviltä

int x = a + b * ((2 - c) / a + b);

Kirjoita luku, jonka muutettu ohjelma tulostaisi.

Kun olet vastannut kysymykseen, voit tarkistaa vastauksesi muuttamalla 1. kohdan koodia.

c) Muutetaan pääohjelmaa seuraavasti:

Mikä ongelma tässä tulee? Mieti ja vastaa kysymykseen, ennen kuin käännät ohjelman. Kun ajat ohjelman, mitä huomaat?

d) Tehdään seuraavanlainen pääohjelma:

Mitä ohjelma tulostaa? Mikä on c:n arvo viimeisen rivin jälkeen? Vastaa kumpaankin kysymykseen yksi luku, kumpikin omalle rivilleen. Kun olet vastannut kysymykseen, voit tarkistaa vastauksesi ajamalla yllä olevan koodin (kunhan ensin korjaat sen toimivaksi).

Tehtävä 2. Binääriluvut

M: 26. Lukujen esitys tietokoneessa. Binäärilukujärjestelmässä on kaksi numeroa, nolla ja yksi. Tätä sanotaan bitiksi (binary digit). Vähiten merkitsevä eli viimeisimmäksi kirjoitettu bitti tarkoittaa lukumäärää yksi, toiseksi vähiten merkitsevä bitti lukumäärää kaksi, kolmanneksi vähiten merkitsevä lukumäärää neljä ja niin edelleen aina kakkosen potensseja jatkaen (8, 16, 32, 64, ...). Kokonaisen binääriluvun ilmoittama lukumäärä saadaan kun summataan nämä yksittäisten bittien ilmoittamat lukumäärät toisiinsa. Esimerkiksi binääriluku 1000101 olisi kymmenjärjestelmässä:

1*64 + 0*32 + 0*16 + 0*8 + 1*4 + 0*2 + 1*1 == 69

Muunna seuraavat binääriluvut ihmiselle tutumpaan 10-järjestelmään:

10010 
1001110001 
1000000000000000 
1010101010101011 
10000000000000001 
10000000000000010 
10000000000000011

Muista vastaukseen laittaa myös aukilaskettuna se, miten sait tuloksen. Pelkkä numero ei riitä.

Nykytietokoneissa on tyypillistä jakaa muisti kahdeksan bitin mittaisiin tallennuspaikkoihin eli tavuihin (byte). Mikä on suurin kokonaisluku, jonka voit tallentaa kahden tavun (eli 16 bitin) kokoiseen tilaan (oletetaan että negatiivisia lukuja ei tarvitse esittää)? Entäpä jos pitää voida esittää positiivisia ja negatiivisia lukuja: mikä silloin on toisaalta pienin ja toisaalta suurin luku, joka kahden tavun kokoiseen tilaan mahtuu?

Tehtävä 3. Algoritmit

M: 3. Algoritmit: Kirjoita suomenkielinen (ei ohjelmointikielinen) algoritmi eli toimintaohje, jolla kuvaat:

• miten "wanhasta" kirjan näköisestä paperisesta puhelinluettelosta etsitään tietyn henkilön puhelinnumero
• millaisella algoritmilla puhelinluettelosta löytyy tietyn numeron omistaja
• kumpi algoritmeista on nopeampi ja miksi?

(Vinkki: Lue Luku3).

M: 3. Algoritmit: Pitäydy tässä tehtävässä vielä irti C#:sta ja muista ohjelmointikielestä. Kuvaile suomen kielellä tai korkeintaan ''pseudokoodilla'', miten jakaisit seuraavat tehtävät yhtä pykälää tarkemmiksi osatehtäviksi. Jaa sitten vielä kukin osatehtävä seuraavalle tasolle pienemmiksi osatehtäviksi. Käytä jotakin luonnollisia ilmauksia toistolle ja päätöstilanteille ("jos ... niin ... mutta muussa tapauksessa ..."):

1. Tiskaaminen
2. Kahvin keittäminen
3. Ohjeet kuinka kurssin sivuilta löytää kurssilla käytettävän sanaston (joka ei siis ole se tynkä luentomonisten lopussa).

Tehtävä 4*. ATK

Laskettava montako karkkia opettaja heittää luennolla keskimäärin.

Opettaja heittelee luennoilla karkkeja. Luennolla heitettyjen karkkien määrä on luentokerroittain kokonaislukutaulukossa (taulukko). Ne luennot, joilla ei ole heitetty yhtään karkkia, jätetään laskematta tulokseen, eli keskiarvo lasketaan vain niiltä päiviltä, jolloin karkkeja on heitetty. Luonnollisesti myös negatiiviset arvot hylätään. Keskiarvon laskeminen lopetetaan (eli keskiarvo on tätä edeltävien hyväksyttyjen alkioiden keskiarvo) mikäli taulukosta tulee vastaan luku 99 tai suurempi. Tätä tapausta vastaa alla olevan taulukon mallilasku M1 (vialliset = 0, lopetus=99).

Jotta algoritmi olisi yleiskäyttöisempi annetaan taulukon lisäksi parametrina minimiarvo (vialliset), joka vastaa alkuperäisen ongelman arvoa 0 (eli alkuperäisen "negatiiviset" tarkoitti että pienempiä kuin vialliset). Yleiskäyttöisyyden vuoksi algoritmille annetaan vielä parametrina lopetusarvo, joka vastaa alkuperäisen ongelman arvoa 99 (lopetus). Mikäli keskiarvoa ei voi laskea, käytetään laskun tuloksena vialliset arvoa.

Laske em. sääntöjen mukaiset keskiarvot seuraavista arvoista. Aluksi on muutama mallilasku (M1, M2 ja M3).

Tehtävä 5*. Portaat

M: 6. Aliohjelmat: Täydennä alla oleva ohjelma Portaat.cs toimimaan niin, että se piirtää 5 porrasta. Ole tarkkana että ohjelma muodostaa kokonaisuuden, eli katso Näytä koko koodi kohdasta että mitä on valmiina (luokka), eli älä lisää sitä enää.

Vinkki: Shape.Rectangle. (Huomaa että TIMissä on ohjelmarunkoa sen kirjoitusikkunan ulkopuolella - katso Näytä koko koodi - eikä using tai Main rivejä kirjoiteta. Ole tarkkana myös sulkujen kanssa! Samoin jos ajetaan Visual Studiossa Jypelin projektimalleista tehtynä, niin Main menee Ohjelma.cs tiedostoon ja omaan koodiin ei enää saa Main-funktiota kirjoittaa. )

Vinkki: Katso 4. luennon LumiukkoAli, jossa piirretään pallo (mutta on myöskin aliohjelma PiirraLumiukko, jota ei tarvita tässä tehtävässä tai oikeastaan tämän tehtävän pääohjelma (Begin) on kuten PiirraLumiukko luennon tehtävässä.

Tuloksen pitäisi näyttää sijaintia lukuunottamatta tältä

Vinkki: Jos haluat sijainninkin samalla tavalla kuin mallikuvassa, voit lisätä Begin-metodin loppuun: Camera.ZoomToAllObjects(50); Loppuun lisääminen tarkoittaa että laitetaan ennen Begin-metodin lopettavaa aaltosulkua.

Tehtävä 6. Ympyrät kolmion muotoon

M: 6. Aliohjelmat: Aja alla oleva ohjelma, joka piirtää lumiukon.

Huom! Yritä tehdä ohjelmasta sellainen, että ympyröiden säde on yhdessä paikassa. Tällöin muuttamalla sädettä syntyy täsmälleen samanlainen kuva, eri "mittakaavassa". Saat merkitä tehtävästä yhden pisteen vaikket tuossa "yleistämisessä" vielä onnistuisikaan.

1. Muuta ohjelma sellaiseksi, että yksittäisen pallon piirtämiseksi on oma aliohjelma PiirraPallo. Mieti mitä parametreja pallon piirtämiseksi tarvitaan.
2. Muuta sitten ohjelma sellaiseksi, että se piirtää kuusi ympyrää kolmeen riviin siten, että ympyrät juuri koskettavat toisiaan. Alla mallikuva ratkaisusta. Anna ympyröille säteeksi 50.

Vinkki: Piirrä paperille kolme toisiaan sivuavaa ympyrää ja niiden keskipisteiden muodostama kolmio. Laske kolmion korkeus (ks. System.Math.Sqrt. Esimerkiksi Pythagoraan lauseesta saataisiin hypotenuusan c pituus ratkaistua näin: c = Math.Sqrt(a*a + b*b) ).

L1. Liukuhihna

Dokumentissa Liukuhihna on hauska robotti. Vastaa siellä oleviin kysymyksiin. Maksimissaan voit tuolta kerätä 2.5 p. Kirjoita alla olevaan tehtävään miltä liukuhihnatehtävä tuntui ja laita itse tehtävän pisteisiin liukuhihnan tuloksesi. Saat tehdä tähän demoon tehtävästä osan ja kolmaanteen demoon osan, kunhan kumpaankin merkkaamasi (demo2 + demo3) summa on sama kuin Liukuhihnatehtävän pistemäärä.

Huom! Pisterajatarkistus ei vättämättä toimi, joten et saa huijata laittamalla liikaa pisteitä!

B1. Harjoitustyö

Kurssille kuuluu harjoitustyö, mutta mitä harjoitustyössä sitten pitäisi tehdä? Jollei valmista peli-ideaa ole, tutustu aiempien vuosien tuotoksiin ja raportoi mietteesi kolmesta eri (Jypeli) pelistä tai ei-pelistä. Liitä mukaan myös linkki, mistä ko. pelin/videon/ohjelman löytää.

Alla linkkejä, mistä voi löytää peleihin liittyviä videoita ja itse pelejä:

• Ohjelmointi 1, kevät 2017
• Ohjelmointi 1, syksy 2016
• Ohjelmointi 1, kevät 2016
• Ohjelmointi 1, syksy 2015
• Ohjelmointi 1, kevät 2015
• Ohjelmointi 1, syksy 2014
• Ohjelmointi 1, kevät 2012 (Youtube)
• Ohjelmointi 1 Kevät 2011
• Nuorten Peliohjelmointikurssi Mallipelejä
• Nuorten pelikurssin pelejä, kesä 2012 (Youtube)

• ei-peli tutoriaali

Tietokoneesta, johon on Jypeli asennettuna, löytyy käynnistä-valikosta Jypelin alta myös esimerkkipelejä (jos ei toimi, klikkaa hiiren oikealla ja käynnistä järjestelmänvalvojana/run as administrator).

Katso myös video GalaxyTripin tekemisestä ja sen lähdekoodi.

B2. Alice ja puut

Tämä jälkeen ei ole enää Alice-demoja, eli jos sitä ei ole vielä asentanut, niin kannattaa miettiä asentaako tämän takia.

Joko Alice 2.3: Aloita avaamalla Alicen luisteluesimerkki Eli aloita luistelu-tutorial ja poistu siitä saman tien. Taustalla on puita. Laita kaksi niistä saapumaan luistelijan luo niin, että ensimmäinen saapuu 2 sekunnin aikana ja "kaatuu" 45 astetta vasemmalle sen jälkeen, kun toinen on saapunut. Ensimmäisen kaatumisen jälkeen toinen kaatuu 45 astetta oikealle. Tehtävän vastauksena palauta lisäämäsi "ohjelmarivit" käsin tekstiksi kopioituna tyyliin

IceSkater.do simple spin

Tai Alice 3: Luo maailma missä on vähintään 3 "oliota". Sitten kuten edellä että kaksi saapuu sen kolmannen luo ja kaatuu kuten edellä.

B3. Khan Academy ja Code Org

Tässäkin kannattaa miettiä viekö erilainen materiaali omaa edistymistä eteen- vai taaksepäin. Jotkut kokevat hyödylluseksi, toiset ajanhukaksi.

Tee Khan Academyn "luennot" Intro to Variables ja More on Variables. Kokeile lisätä koodiin joku oma muuttuja ja kokeile muutella sitä.

Kokeile myös Code.orgia

Tehtävän vastauksena kerro mielipiteitä Khan Academyn "luennoista" ja käytön järkevyydestä tällä kurssilla.

G1-2. Tippuvat suorakulmiot

Tee ohjelma nimeltä SuorakulmiotFysiikalla.cs. Tee siihen aliohjelma nimeltä PiirraSuorakulmio(), joka lisää ruudulle (peliin) PhysicsObject-tyyppisen suorakulmion. Tee aliohjelma siten, että se ottaa parametrinä pelin, suorakaiteen koordinaatit ja mitat. Laita peliin vielä painovoima seuraavasti (2d-vektori ottaa vastaan kaksi koordinaattia) ja sijoita se Begin()-aliohjelmaan

Gravity = new Vector(/*täydennä 2d-vektorin parametrit...*/);

Vector-luokan dokumentaatio.

Laita kenttään myös reunat, etteivät palaset putoile ulos ruudusta.

Level.CreateBorders();

Lisää kentälle 100 satunnaisen kokoista suorakaidetta satunnaiseen paikkaan. Vinkki: for-silmukka ja RandomGen.

HUOM! Timissä näkyy kuvasta vain 1. frame eikä siinä ole mitään liikettä.

Tauno 1 a

Koita vastauksissa välttää turhia apumuuttujia ja mieti kuinka hyvin ratkaisusi yleistyy jos taulukon kokoa kasvatetaan.

Lisää aluksi Taunossa tulos-niminen muuttuja ja tee sitten Taunolla ohjelma, joka laskee tulos-muuttujaan parillisissa paikoissa olevien lukujen summa miinus parittomissa paikoissa olevien summa. Alkuperäistä taulukkoa ei saa muuttaa.

Esim:
5 4 6 2 9 1 => (5-4) + (6-2) + (9-1) = 13

Tauno 1 b

Lisää aluksi Taunossa tulos-niminen muuttuja ja tee sitten Taunolla ohjelma, joka laskee yhteen taulukon luvut niin, että summa (1. - viimeinen) + (2. - toiseksi viimeinen) jne... (kunnes kaikkiin on "koskettu") on lopuksi tulos-nimisessä muuttujassa. Edellä 1. tarkoittaa ensimmäinen.

Esim:
5 4 6 2 9 1 => (5-1) + (4-9) + (6-2) = 3

Ville 1

Tee Ville-tehtävät: 3.1, 3.2, 3.4, 7.1 - 7.6. (Villessä voi olla virhe, että Sum on välillä kirjoitettu isolla ja välillä pienellä, kuvittele että se on aina kirjoitettu isolla alkukirjaimella.)

Muista: Villen käyttöohje.

Tehtävä 1. Negatiiviset binääriluvut

M: 26.4 Negatiiviset binääriluvut:

Tämän tehtävän selitys ja itse tehtävät vievät sen verran tilaa, että ne on oletuksena piilotettu. Aukaise tehtävä [+]-merkistä tai otsikosta klikkaamalla.

Tehtävä 2. Muuttujien tyypit ja nimet

M: 7. Muuttujat. Miten esittelisit (tyyppi ja nimi) muuttujat seuraavia tilanteita varten. Anna myös esimerkki miten sijoittaisit muuttujalle jonkin arvon. Kirjoita yksi kohta per rivi.

a) Työmatkan pituus polkupyörällä
b) Suoritettujen opintopisteiden määrä 
c) Koko tutkinnon laajuus opintopisteissä
d) Tehtyjen demojen lukumäärä 
e) Kirjan ensimmäinen kirjain
f) Sadan metrin juoksun voittajan aika.
g) 3 kuukauden euribor-korko
h) euron markka-muuntokerroin

Tehtävä 3. Muuttujien nimien kritisointia

M: 7. Muuttujat. Arvostele seuraavat muuttujien tyypit ja nimet. Ovatko syntaktisesti oikein? Entä ovatko hyviä valintoja:

int mansikanKiloHinta;
double default;
char omaNimi;
double metriMm;
double tuntejaVuorokaudessa;
real nopeus;
boolean AuringonEtaisyys;
ulong kuukaudenKeskiLampo;
int kissoja,2_kanaa,kolmeKoiraa;
int i,j,l,I;

Tehtävä 4*. Funktioita

M: 9. Aliohjelman paluuarvo, erityisesti YmpyranAla paluuarvo.

Lue myös 6.2 Aliohjelmien kirjoittaminen.

Vaihda ISOLLA kirjoitettujen sanojen tilalle oikeat sanat ja sitten täydennä funktio KuutionTilavuus toimivaksi. Älä vaan lisää parametrien määrää, koska yksi riittää!

Katso tehtävissä Näytä koko koodi, niin näet, miten funktioita kutsutaan ja samalla näet, mitä on valmiina ja mitä kirjoittamatta.

Huomaa, että tehtävissä, joissa on Aja ja Test -painikkeet sekä Document-linkki, pitää sinun painaa niitä kaikkia saadaksesi täydet pisteet tehtävästä.

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Muutamilla seuraavia virheitä (vaikka olisiki täydet pisteet, samoja virheitä myös T5):

• sisennykset väärin
• jos kutsutaan funktiota, sulku kiinni nimeen
• ei ole olemassa operaattoria s^3
• muuttujien nimien pitää alkaa pienellä kirjaimella
• tyyppi on double eikä Double
• dokumenttikommentit tulevat ennen funktion esittelyriviä
• dokumenttikommenteissa (jotka oli nyt jo valmiina) pitää esitellä myös parametrien nimet ja paluuarvon
• valmiissa kommentissa oli parametrin sivunpituus nimeksi annettu s ja sitä pitäisi käyttää!
• turhia tyhjiä rivejä
• parametria ei saisi käyttää apumuuttujana

Tehtävä 5*. FahrenheitToCelsius

M: 9. Aliohjelman paluuarvo. Lue myös 6.2 Aliohjelmien kirjoittaminen. Katso netistä miten fahrenheitit muunnetaan celsius-asteiksi. Älä kuitenkaan Copy/Paste sieltä mitään, sillä miinusmerkiltä näyttävä merkki ei välttämättä ole siellä - vaan muuten vaan saman näköinen merkki. Desimaalierottimena maasta riippumatta C#:issa käytetään pistettä (.) ei pilkkua (,). Kirjoita (funktio)aliohjelma, jota voidaan kutsua seuraavasti esim. 13°F muuttamiseksi Celsius asteiksi:

double lampotilaC;
lampotilaC = FahrenheitToCelsius(13);

Katso tehtävissä Näytä koko koodi, niin näet miten funktioita kutsutaan ja samalla näet mitä on valmiina ja mitä on kirjoittamatta. Vertaa nyt edelliseen tehtävään ja kirjoita siis itse kaikki mitä edellisen tehtävän pohjassa oli kirjoitettu ISOilla kirjaimilla.

Tämä tehtävä kannattaa harjoitella VisualStudiolla tekemällä ConsoleMain mallin avulla konsolisovellus (aukaise ohje [+]-merkistä):

HUOM: Tehtävä on TÄYSIN identtinen edellisen Kuutio-tehtävän kanssa. Voit kirjoittaa samaan luokkaan monta funktiota (vrt: luentojen video ja esimerkki Funktioita.cs tai sama kommentoimattomana). Jos teet Visual Studiossa, niin kopioi vastauslaatikkoon vain funktion esittelyrivi JA toteutus. Pääohjelma, kommentit ja testit ovat tässä TIM-tehtävässä jo valmiiksi mukana.

Kirjoita vastaava funktio, joka muuntaa mailit (brittiläiset) kilometreiksi. Katso kaava muunnosta varten Wikipediasta.

Tehtävä 6. Aritmeettiset lausekkeet

M: 7.7 Operaattorit (ja aritmeettiset lausekkeet). Kirjoita lausekkeet, joilla lasket muuttujiin, joille olet valinnut hyvät nimet, alla luetellut arvot. Tee Console C#-ohjelmaksi, Main() riittää, ei tarvitse aliohjelmia:

a) vuorokauden sekuntien lukumäärän
b) vuoden tuntien lukumäärän
c) kauanko valolla kuluu aikaa matkaan auringosta maahan 
   (keskietäisyydet riittävät).
d) valovuosi kilometreinä

Tulosta muuttujien arvot. Periaatteessa tyyliin:

  int tunnissaSekunteja = 60*60;
  System.Console.WriteLine("Tunnissa sekunteja {0}",tunnissaSekunteja);

L1. Liukuhihna

Dokumentissa Liukuhihna on hauska robotti. Vastaa siellä oleviin kysymyksiin. Maksimissaan voit tuolta kerätä 2.5 p. Kirjoita alla olevaan tehtävään miltä liukuhihnatehtävä tuntui ja laita itse tehtävän pisteisiin liukuhihnan tuloksesi. Saat tehdä tähän demoon sen tehtävästä osan jota et jo tehnyt demo2:ssa, kunhan kumpaankin merkkaamasi (demo2 + demo3) summa on sama kuin Liukuhihnatehtävän pistemäärä.

Huom!. Pisterajatarkistus ei vättämättä toimi, joten et saa huijata laittamalla liikaa pisteitä!

B1. Pallojen pukkailu

Katso Voimia ja sitominen. Tee ohjelmasta sellainen, että voit "pukkailla" keskipalloa nuoli vasemmalle ja nuoli oikealle näppäimillä. Tehtävä kannattaa tehdä Visual Studiolla, koska TIMillä ei voi tehdä interaktiivisia C#-pelejä. Kopioi tekemäsi koodi alle ja paina aja-nappia. Tosin näet vain ensimmäisen pelikierroksen staattisen kuvan.

(Huom. Kun olet tallentanut vastauksesi, arvioi oma suoriutumisesi tehtävästä asteikolla 0-1p. valitsemalla automaatin antaman pistemäärän vierestä Set custom points.)

B2. Kuormittaminen

M: 6. Aliohjelmat (Kuormittaminen). Ota Demo 2:n Portaat-esimerkki (poista Main jos teet Visual Studiolla Jypelin projektimallista, koska sieltä tulee oma Main sinne Program.cs-tiedostoon). Tehtävänä on muuttaa ohjelma sellaiseksi, että PiirraNelio-aliohjelmaa voidaan kutsua kahdella eri tavalla (eli on kaksi eri PiirraNelio-aliohjelmaa joissa eri parametrimäärät kummassakin):

a) Ilman "sädettä", piirtää aina neliön, jonka sivu on 80  
   (parametrina siis keskipisteen koordinaatit) 
      PiirraNelio(this,0,0);  // kuten nyt portaiden piirtämisessä
b) antamalla neliön "säde" (eli puolet sivun pituudesta, näin se 
   on helpompi samaistaa ympyrään) koko    
      PiirraNelio(this,0,0,50); // neliö, jonka sivunpituus on 100.

Ennenkuin teet mitään muutoksia, kokeile niin, että Jypelin pääohjelma (Begin) on täsmälleen sama kuin mallissa portaiden piirtämiseksi. Kun tämä toimii, lisää Begin-metodiin portaiden jälkeen vielä yksi rivi niin, että piirretään yksi erikokoinen neliö portaiden ulkopuolelle (eli kutsutaan uutta 4 parametristä aliohjelmaa). Muista kommentointi! Vinkki: Ks: kuormitettu lumiukko, luento 05 tai Monisteen luku aliohjelman kuormittamisesta (function overload).

(Huom. Kun olet tallentanut vastauksesi arvioi oma suoriutumisesi tehtävästä 0-1p. asteikolla valitsemalla automaatin antaman pistemäärän vierestä Set custom points)

B3. Prosessorin toiminta

Alla olevat linkit voit avata toiseen ikkunaan tai tabiin ja katsoa niitä välillä samalla kun katsot videota.

• Yksinkertainen CPU
• Ollaan tietokoneena

Katso alla oleva video ja täytä alla olevia prosessorin rekistereitä samaa tahtia kuin videossa. Kannattaa painaa Ins-painiketta, niin voi kirjoittaa ilman että työntää edellä olevia merkkejä eteenpäin.

Ohjelmamuisti:
==============

100   102   104   106   108   10A   10C   10E   110
B3 62 80 FB 61 72 08 80 FB 7A 77 03 80 EB 20 A1 F4 .. .. ..

Käskyjen merkitys:
==================

72     = jos vertailu oli pienempi, niin lisää ohjelmalaskuriin
         seuraavan tavun arvo
         IP+2
77     = jos vertailu ei ollut pienempi tai yhtäsuuri lisää
         ohjelmalaskuriin seuraavan tavun arvo
         IP+2
80 EB  = vähennä BL-rekisterin arvosta seuraava tavu
         IP+3
80 FB  = vertaa BL rekisterin arvoa seuraavana olevaan tavuun
         IP+3
A1 F4..= tulosta kirjaimena BL-rekisterissä oleva luku
B3     = ota seuraavana oleva tavu ja laita se BL-rekisteriin
         IP+2

G1-2. Suppeneva laatikkojono

Jatketaan demo 2 tehtävää 5. Tee ohjelmasta sellainen, että se piirtää viiden laatikon sijaan n laatikkoa, vieläpä siten, että laatikot pienenevät. Tällöin i:nnen laatikon koko tulisi olla

(n+1-i) / n * laatikonKoko

missä laatikonKoko on ensimmäisen laatikon sivun pituus. Esimerkiksi jos halutaan piirtää yhteensä 10 laatikkoa, niin 7:nnen laatikon koko on

10+1-7 / 10 = 4/10 * laatikonKoko

(Huom. Kun olet tallentanut vastauksesi arvioi oma suoriutumisesi tehtävästä 0-2p. asteikolla valitsemalla automaatin antaman pistemäärän vierestä Set custom points)

TDD 1

Lisätehtävä "ammattilaisiksi" tähtääville.

Jos tarkistat vähintään kahden funktion toiminnan automaattisella testillä (ComTest), saat merkitä yhden lisäpisteen. Vastauksena kerro minkä tehtävän ja minkä funktion/funktioiden toiminnan testasit. Voit antaa vastauksessa palautetta ja kehitysehdotuksia ComTestin käytöstä. Huom! Ohjelmia joissa on pelkkä pääohjelma on vielä tämän kurssin tiedoilla aika haastava testata, samoin esim. peli-juttuja. Siksi testaamista kannattaa ehkä tehdä tässä demoissa vain sellaisille funktioille, jotka selkeästi palauttavat jotakin. Tässä demossa sellaisia on tehtävässä 4 ja 5. Tämän kirjoittaminen antaa sinulle 0.5 p ja saat itse nostaa yhteensä 1 p jos olet VisualStudiossa tai Xamarinissa kirjoittanut vähintään kahteen funktioon itse testejä (erilaisia kuin mitä näistä demoista saa kopioimalla).

Tauno 1a

Katso ensin video Demo 3:n Tauno-tehtävän käsittelystä. Koita vastauksissa välttää turhia apumuuttujia ja mieti kuinka hyvin ratkaisusi yleistyy jos taulukon kokoa kasvatetaan.

Tauno 1b

aa

Ville 1

Tee Ville-tehtävät 3.3, 3.5, 3.6. 4.1-4.4. Villen Substring-tehtävät toimivat väärin (toimivat kuten Javassa, eli parametrit ovat alku,loppu+1, kun C#:ssa ne olisivat alku,pituus. Tulos on molemmissa sama jos alku == 0, muuten eri. Eli 3.5 tehtävästä menee väärin rivi 4.). Vastatkaa C#:in mukaan älkääkä välittäkö väärästä tuloksesta. 3.6 tehtävässä substring toimii javan mukaan: parametreinä ovat indeksi josta aloitetaan ja indeksi, jota ei oteta enään mukaan. Esimerkiksi s = "helpotus"; s.Substring(1,5) ==> "elpo";

Muista Villen käyttöohje.

Funktioista

Mikäli olit luennolla ma 25.09.2018 voit hypätä kohdan 1 yli ja jatkaa suoraan tämän tehtävän kohdasta 2.

1. Mikäli et ollut luennolla tai et saanut luennolla tehtyä sitä tehtävää, jossa opiskelijat "leikkivät" aliohjelmia ja paperilaput parametrejä, tee se nyt ainakin yhden kaverin kanssa. Tarvittaessa pyydä kaveriksi joku, joka ei ole ohjelmointikurssilla. Hätätilassa "valvoja" voidaan jättää pois tehtävästä. Tehtävät näet alla olevasta osoitteesta:

   • Opiskelijat aliohjelmina

2. Seuraavaksi lue huolella monisteen luku 9. Aliohjelman paluuarvo.

3. Suorita kohdan 9.2 Funktion kutsuminen lopussa oleva animaatio huolella miettien, mitä tapahtuu ja miten asiat samaistuvat luentojen "paperilappujen leikkiesimerkkiin".

4. Aja kohdan 9.3 Funktion kirjoittaminen toisella tavalla toisen esimerkin testit. Vaihda 2.0 tilalle 2. Aja testit ja katso, mitä tapahtuu. Vaihda jakolaskun tilalle kertominen luvulla 0.5 ja aja testit uudelleen.
   

5. Katso merkkijonoista oleva animaatio.

Kirjoita alle:

• mitä opit animaation ja luentojen paperilappujen antamisen yhteydestä?
• mitä hyötyä oli testeistä?
• miksi sanotaan, että merkijono on muuttumaton (immutable) vaikka merkkijonoanimaation esimerkissä muuttuja jono muuttui?

TDD 1

M: 11. Comtest

Jos teet itse omia testejä vähintään kahteen funktioon (esim ComTest) Visual Studiossa tai vastaavassa, saat merkitä yhden lisäpisteen. Testit eivät saa olla täsmälleen samoja kuin mitkä saa kopioimalla tehtävien TIM-versiosta. Vastauksena kerrot minkä tehtävän ja minkä funktion/funktioiden toiminnan testasit. Voit antaa samalla palautetta ja kehitysehdotuksia Comtestin käytöstä. Huom! Ohjelmia joissa on pelkkä pääohjelma on vielä tämän kurssin tiedoilla aika haastavaa testata, samoin esim. pelijuttuja. Siksi testaamista kannattaa ehkä tehdä tässä demoissa vain sellaisille funktioille, jotka selkeästi palauttavat jotakin. Tässä demossa sellaisia on tehtävissä 2, 5 ja 6.

Jos ComTest ei toimi koneellasi, voit Copy/Pasteta ohjelmia alla olevaan laatikkoon ja testata siinä.

Tehtävä 1. Pong tai työaikatutoriaali

Valitse seuraavista jompikumpi sen mukaan mikä on kiinnostus peleihin:

1. Jos et tykkää pelin tekemisestä, niin tutustu Työaikaraportti tutoriaaliin Toki voit tämän toisen tutoriaalin tehdä myöhemmin vaikka peleistä pitäisitkin :-) Kuten Pongissakin, kirjoita alle muutaman kappaleen mittainen oppimispäiväkirja

2. Tee Pong-tutoriaalista vaiheet 4-7. Pong-tehtävää ei voi tehdä TIMissä! (Tee myös 1-3 jos et niitä ohjauksissa tehnyt.) Kirjoita parin kappaleen mittainen oppimispäiväkirja (väh. 5 riviä), eli mitä opit, mikä oli uutta? Mikä oli helppoa ja mikä vaikeaa? Oliko tästä tehtävästä sinulle hyötyä? Voit antaa myös palautetta tutoriaalin sisällöstä. Pong-tutoriaalin kooditiedostoja EI tarvitse palauttaa.

Älä jää liikaa suremaan hieman omituista fysiikan käytöstä joissakin pompuissa :-)

Tehtävä 2*. Merkkijonoja vertaava funktio

Tätä tehtävää tehdessä älä yhtään mystifioi asioita. Kyseessä on periaatteessa täsmälleen samanlainen tehtävä kuin viikko sitten Kuutio tai Fahrenheit. Ainoastaan funktion tyyppi on eri, samoin parametrien tyypit. Ja toki sisällöllinen toteutus johon kannattaa panautua vasta kun on toimiva tynkä tehtynä.

M: 12. Merkkijonot, 13. Ehtolauseet, Aliohjelminen kutsuminen, Merkkijonoja.cs

• katso erityisesti animaatio siitä, miten merkkijonofunktio toimii: ToLower
• käytä ensisijaisena lähteenä luentomonisteen Merkkijonot-lukua

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tee alla olevaan (ConsoleMain-projektin) pääohjelmaan tarvittava funktio PidempiMerkkijono. Huomaa! TIMissä täytyy syöte antaa etukäteen input-kenttään. Paremman kuvan toiminnasta saat oikeassa ympäristössä (Visual Studio).

 public static void Main()
 {
     Console.Write("Anna 1. sana >");
     string sana1 = Console.ReadLine();
     Console.Write("Anna 2. sana >");
     string sana2 = Console.ReadLine();
     string pidempi = PidempiMerkkijono(sana1, sana2);
     Console.WriteLine("\"" + pidempi + "\" on pidempi sana");
 }

Muista että ensin teet funktion esittelyrivin (sen missä on public static jne...). Sitten kirjoita funktion dokumentaatio (se /// ja täydennä summary ja parametrien merkitys). Lisätietoa TIM-sivulta aliohjelmien kirjoittamisesta. Aluksi itse funktion sisältö voi olla vaikka pelkkä:

return "testi";

Sitten kokeilet, että ohjelma kääntyy ja kyselee ja tulostaa tuollaisenaan. Kun se toimii, voit ruveta muuttamaan funktion sisältöä niin, että funktio tekee sen mitä pitääkin.

Paitsi jos teet kunnon TDD:tä (Test Driven Development), niin ennen funktion toteutusta kirjoitat testit ja kokeilet, että testit epäonnistuvat. Sitten vasta toteutat funktion ja ajat testit, korjaat funktiota, jos testit eivät toimi jne... Testit (ks. Näytä koko koodi) tätä funktiota varten voisivat olla esim:

///  PidempiMerkkijono("Eka sana", "toka") === "Eka sana";
///  PidempiMerkkijono("Eka", "Toka") === "Toka";
///  PidempiMerkkijono("Eka", "Tok") === "Eka";
///  PidempiMerkkijono("", "Toka") === "Toka";
///  PidempiMerkkijono("", "") === "";

Muista jakaa tehtävä osiin:

1. saan kaksi merkkijonoa, pidempi pitää palauttaa
2. mistä olen ensin kiinnostunut? en jonojen sisällöstä vaan niiden XXX?
3. miten saan selville XXX? Mikä on XXX tyyppi?
4. vertaa jonojen XXX ja päättele sen perusteella mitä palautetaan? Mitä tyyppiä palautettavan tuloksen pitää olla?

Kun olet tehnyt tehtävän, niin kopioi funktio esittelyriveineen tuohon alapuolelle.

Tehtävä 3 Lässytystä

M: 12. Merkkijonot. Luennon 08 esimerkki Merkkijonot.cs, Aliohjelminen kutsuminen

Huomaa! TIMissä konsolilta lukeminen ei toimi samalla tavalla kuin oikeassa ohjelmassa. TIMissä käyttäjän syöte pitää antaa sille varattuun tilaan ENNEN ohjelman ajamista.

Tee Console-ohjelma, joka toimisi seuraavasti (vinkki: katso String-luokan dokumenttia ja etsi metodi, jolla voit vaihtaa kirjaimia. Tiedon lukemista varten katso edellisen tehtävän pääohjelmaa (tässä tehtävässä ei välttämättä tarvitsisi itse kirjoittaa yhtään aliohjelmaa, tosin tulevia demoja ajatellen apufunktiosta ei ole haittaakaan).

Toistan mitä sanot, mutta en osaa sanoa r:ää!
Anna teksti  >ralliauto ajaa superkovaa.
Sanoit siis : lalliauto ajaa supelkovaa.

Muutamilla seuraavia virheitä (vaikka olisiki täydet pisteet, samoja virheitä myös T5):

• sisennykset väärin
• jos kutsutaan funktiota, sulku kiinni nimeen
• muuttujien nimien pitää alkaa pienellä kirjaimella
• valmiissa kommentissa oli parametrin sivunpituus nimeksi annettu kause ja sitä pitäisi käyttää!
• turhia tyhjiä rivejä
• parametria (lause) ei saisi käyttää apumuuttujana, kannattaa esitellä uusi apumuuttuja

Tehtävä 4. Char-luokka

Kirjaimet: Katso ensin huolellisesti luennon 08 esimerkki Merkkijonot.cs. Sitten katso char-dokumentaatiota, Aliohjelminen kutsuminen

Tehtävä 4a. Kirjain isoksi (0.4 p)

Katso, mikä kutsu sinun on kirjoitettava XXX:n paikalle, jotta seuraava ohjelma toimisi:

Tehtävä 4b. Onko iso? (0.6 p)

Oletetaan että tehtävänä olisi tehdä ohjelma, jossa kysytään käyttäjältä merkki ja tulostetaan, onko se iso kirjain (uppercase) vai ei (lower case).

Tehtävä kannattaa ilman muuta silloin aloittaa niin, että ensin tehdään funktion IsoVaiPieni, joka selvittää merkkijon 1. kirjaimen suuruuden. Sitten kun tämä on tehty ja testattu, ruvetaan miettimään käyttäjältä kysymistä. Tässä tehtävässä tyydytään vasta tuon funktion tekemiseen.

TIM-versiossa pääohjelmassa on vakiojono, jossa funktiolla selvitetään, onko jonon 1. kirjain iso vai pieni. Katso tarkasti, mitä itse funktiossa testataan (Näytä koko koodi) ja mieti, mitä mikäkin tapaus tarkoittaa funktion kannalta. (Array index is out of range = taulukon indeksi on rajojen ulkopuolella, saattaa liittyä tyhjään merkkijonoon. Eli mitä on mj[0] jos mj = "" :-) Katso myös luentomoniste.

Jaa ongelma ensin selkeästi pienempiin osiin:

1. Voinko edes ottaa 1. kirjaimen? Missä tilanteessa en? Mitä silloin palautetaan?
2. Miten saan jonon 1. kirjaimen?
3. Miten tutkin, onko 1. kirjain iso?
4. Miten tuon perusteella palautan tekstin "iso" tai "pieni"?

Tehtävä 5*. Kolmen luvun suurin ja pienin

M: 13. Ehtolauseet, Lukuja.cs

Tee ohjelma, joka kysyy kolme kokonaislukua ja tulostaa niistä suurimman ja pienimmän. Tee avuksi funktioaliohjelmat Suurin ja Pienin (joille kummallekin viedään kolme parametriä). Millä arvoilla aliohjelmia olisi hyvä testata? Oletetaan, että käyttäjä syöttää kokonaisluvun, eli poikkeuksia (jokin muu kuin kokonaisluku annettu) ei tarvitse tässä ottaa huomioon. Numeron saat luettua päätteeltä seuraavasti:

Console.Write("Anna 1. kokonaisluku >");
int a = int.Parse(Console.ReadLine());

Vinkki! Tehtävää on helpointa lähteä laajentamaan ajatuksesta

int suurin = a;
if ( b > suurin ) suurin = b;
return suurin;

Tehtävä 6. Merkkijonon pätkiminen

M: 12. Merkkijonot, Jonoja.cs, Merkkijonoja.cs, Aliohjelminen kutsuminen

Tee tarvittavat aliohjelmat, jotta seuraava pääohjelma toimisi (vinkki: IndexOf, Substring tai Split, Split vaatii taulukon jota ei vielä ole käsitelty, muista aina painaa Näytä koko koodi):

public static void Main() 
{
    Console.Write("Anna nimesi muodossa sukunimi etunimi: ");
    string kokonimi = Console.ReadLine();
    string sukunimi = AnnaEkaSana(kokonimi);
    string etunimi = PoistaEkaSana(kokonimi);
    Console.WriteLine("Etunimesi on siis " + etunimi + 
                      " ja sukunimesi " + sukunimi);
}

L1. Liukuhihna

Dokumentissa Liukuhihna on hauska robotti. Vastaa siellä oleviin kysymyksiin. Maksimissaan voit tuolta kerätä 2.5 p. Kirjoita alla olevaan tehtävään miltä liukuhihnatehtävä tuntui ja laita itse tehtävän pisteisiin liukuhihnan tuloksesi. Saat tehdä tähän demoon sen tehtävästä osan jota et jo tehnyt demo2:ssa tai demo3:ssa, kunhan kumpaankin merkkaamasi (demo2 + demo3 + demo4) summa on sama kuin Liukuhihnatehtävän pistemäärä.

Huom!. Pisterajatarkistus ei vättämättä toimi, joten et saa huijata laittamalla liikaa pisteitä!

B1-2. Pallojen pukkaileminen

Ota Demo 2:n mallivastauksista SuorakulmiotFysiikalla.cs. Aja se ensin sellaisenaan. Muuta sitten se niin, että luodaan pelikentälle satunnaisiin paikkoihin 30 palloa (mielellään satunnaisin värein), joilla on satunnainen säde 5 ja 30 välillä. Kokeile että toimii. Lisää vielä yksi 40-säteinen valkoinen pallo jota voi ohjata "tökkimällä" nuolinäppäimillä (katso mallia edellisen demon Lumiukon tökkimisestä). Ohjainten lisäämiseen voit katsoa vinkkiä Pong-tutoriaaleista.

G1. Räjähdys

Lisää edelliseen pallopeliin sellainen ominaisuus, että jos ohjattavalla pallolla osuu toiseen palloon kentän puolivälin yläpuolella, niin toinen pallo räjähtää ja poistuu pelistä (vinkki: Jypelin ohjeet. Pelin tarkoituksen on räjäyttää kaikki pallot.

Demot

Tehtäviä voi tehdä suoraan TIMissä, mutta niitä kannattaa jo ruveta tekemään Visual Studiossa, jolloin niitä voi debugata samalla ja etsiä mahdollisia virheitä siitä, miksi silmukka tms ei toimi. Kun vastauksia kopioi Visual Studiosta TIMiin, kannattaa olla huolellinen, että kopioi nimenomaan sen osan, mikä TIMiin pitäisi kirjoittaa.

Muista: Jotta konsolisovelluksen tekeminen olisi helpompaa, ota "parempi" template ConsoleMain Jypelin alta.

Samaan solutioniin kannattaa tehdä useampi demotehtävä. Suositus, olisi että tekee 1. tehtävää varten projektin, jolle antaa kuvaavan nimen (esim JonojenLisaily ja sen solutionille nimen demo5). Sitten seuraavaa tehtävää varten klikkaa hiiren oikealla Solution Explorerissa Add/New project ja näin lisää projektin olemassa olevaan solutioniin. Muista taas antaa projekille kuvaava nimi!

Tehtävien nimeämisestä: Älä anna C#-tiedostoille nimiä, jotka eivät ole kuvaavia! Esimerkiksi tehtG1.cs on huono sen kannalta, että tarkoitus on opetella käyttämään nimiä, jotka toimisivat oikeassakin ohjelmassa. Pallopeli.cs on taas paljon parempi (ja muista se luokan nimen suhde tiedoston nimeen).

HUOM! Älä käytä C#:in valmiita luokkakirjastojen nimiä omien luokkien niminä! Esim. tehtävässä 1 älä käytä nimeä StringBuilder omalle luokallesi, projektillesi, solutionillesi tms., sillä se peittää (hides) silloin näkyvistä C#:in oman luokan, ja saat vain virheitä jokaisesta rivistä, jossa lukee StringBuilder. Varminta on siis nimetä omia "juttuja" aina tässä vaiheessa opettelua suomenkielisillä nimillä, jolloin vältät nimikonfliktit C#:in valmiiden nimien kanssa.

Kurssin ydinasian kannalta tärkeät tehtävät: Tauno 1, 1, 2, 3, 4 ja 6.

Vinkki: Askella luentomonisteessa silmukka- ja taulukkoesimerkkejä läpi ja seuraa mitä silmukoissa taphtuu. Nuo esimerkit ovat toistaiseksi hieman huonosti näkyvillä ja ne hyppäävät esiin, kun vie hiiren niiden päälle. Niitä löytää, kun etsii jonoa "Animaatio:".

Monisteen lisäksi kannattaa lukea:

• Aliohjelmien kirjoittaminen
• AliohjelmienKutsuminen.cs - luento 9:än esimerkki StringBuilder:in käytöstä ja asiaa Aliohjelmien kutsumisesta
• 1-ulotteiset taulukot
• Taulukoita.cs - luento 10:n malliohjelma (esimerkki myös lukujen tulostamisesta silmukassa)
• Taulukoita.cs - luento 10:n yksinkertaisempi versio, jossa kaikki eri silmukat malliksi samassa aliohjelmassa.

Kunkin kerran minimipistemäärä 2 on tehtävä käyttäen *-merkittyjä tehtäviä. Esim. pelkkä Ville ja Tauno ei riitä minimimäärään. Jos pakolliset tehtävät eivät lähde luonnistumaan, kannattaa käydä pääteohjauksissa tai Pahasti Pihalla -ryhmissä saamassa apua.

Tauno 1

Huomaa, että nyt Tauno on muuttunut. Et voi enää ottaa mitä tahansa taulukon alkiota, vaan sinun pitää ensin luoda indeksimuuttuja (joka tässä tehtävässä sinulle on luotu valmiiksi). Sitten indeksimuuttuja pitää raahata sen taulukon alkion alle, johon sen halutaan "viittaavan" (tehty valmiiksi 1. kerralla). Vain sellaisen taulukon alkion voit raahata jonnekin, jonka alla sinulla on indeksimuuttuja.

Indeksimuuttujan paikkaa voit vaihtaa raahaamalla sen toisen taulukon alkion alapuolella tai kohdentamalla siihen +1 tai -1 operaatioita.

Huom! Jos haluat Taunon sijaan tehdä suoraan silmukoita, niin tee sama silmukkakoodi a) ja b) kohtiin.

Kun olet saanut Taunossa koodin toimimaan, kirjoita alle vastaava koodi silmukalla.

Ville 1

Tee Ville-tehtävät: 4.5, 4.6, 5.1-5.5, 9.1, 9.2, 9.3. Huom! Lue tarkasti kysymykset (montako kertaa, montako tulostetaan). Villen mallissa loppusulkuun } mennään kun silmukka loppuu. Muista Villen käyttöohje.

TDD 1

Jos tarkistat vähintään kahden funktion toiminnan automaattisella testillä (esim ComTest) Visual Studiossa tai vastaavassa, saat merkitä yhden lisäpisteen. Testit eivät saa olla täsmälleen samoja kuin mitkä saa kopioimalla tehtävien TIM-versiosta. Vastauksena kerrot minkä tehtävän ja minkä funktion/funktioiden toiminnan testasit. Voit antaa samalla palautetta ja kehitysehdotuksia Comtestin käytöstä.

Taulukon testaaminen ComTestillä:

  /// int[] luvut = {1,3,6};
  /// String.Join(" ",luvut) === "1 3 6";

Jos haluat viedä testiin taulukon "luomatta" sitä apumuuttujaan, niin seuraava auttaa:

  /// SuurinJaPienin.Pienin(new int[]{1, 2 ,3}) === 1;

Valitettavasti 2-ulotteiselle taulukolle ei ole vastaavaa Join-funktiota, vaan sellaisen joutuu tekemään itse. StringBuilderin arvon testaaminen pitää suorittaa ToString()-metodin avulla.

  ///   StringBuilder j1 = new StringBuilder("123");
  ///   Jonoja.LisaaAlkuunJaLoppuun(j1,"XX");
  ///   j1.ToString() === "XX 123 XX";

Tulostavia tai Jypeliin perustuvia aliohjelmia on turhan vaikea vielä nykytietämyksellä testata ComTestillä.

Tehtävä 1. StringBuilder

M: 12.3 Muokattavat merkkijonot: StringBuilder.
AliohjelmienKutsuminen.cs - katso tämä malliksi siitä, miten StringBuilderin metodeja kutsutaan.

Tee seuraavaan pääohjelmaan tarvittava aliohjelma:

public static void Main()
{
    StringBuilder jono;
    jono = new StringBuilder("kissa istuu");
    LisaaAlkuunJaLoppuun(jono, "***"); // jono muuttuu aliohjelmassa
    Console.WriteLine("Jono on nyt " + jono); 
    // tulostaa: Jono on nyt *** kissa istuu ***
}

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tehtävä 2*. 3-paikkaisen taulukon suurin ja pienin

M: 15. Taulukot.

Otetaan Demon 4 mallivastauksista tehtävän 5 vastaus (SuurinJaPienin.cs) ja muutetaan sen pääohjelma käyttämään taulukoita:

        public static void Main()
        {
            int[] luvut = new int[3];
            Console.Write("Anna 1. kokonaisluku >");
            luvut[0] = int.Parse(Console.ReadLine());
            Console.Write("Anna 2. kokonaisluku >");
            luvut[1] = int.Parse(Console.ReadLine());
            Console.Write("Anna 3. kokonaisluku >");
            luvut[2] = int.Parse(Console.ReadLine());

            int suurin = Suurin(luvut);
            int pienin = Pienin(luvut);

            Console.WriteLine("Suurin luku on " + suurin);
            Console.WriteLine("Pienin luku on " + pienin);
        }

Sitten pitää muuttaa aliohjelmat niin, että ne käsittelevät 3-paikkaista taulukkoa. Tässä TIMiin palautettavassa tehtävässä tehdään vain tuo aliohjelmien (funktioiden) muutos. Muista aluksi vaihtaa esittelyrivin parametrilista oikeaksi, vertaa luentojen Summa-funktio. Tässä 1. taulukkotehtävässäsi saat poikkeuksellisesti olettaa, että taulukossa on TASAN 3 alkiota, jatkossa näin ei saa tehdä. Ideana tässä on siis suurinpiirtein korvata koodissa

 a => luvut[0]
 b => luvut[1]

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tehtävä 3*. Kertotaulu

M: 16. Toistorakenteet.
Taulukoita.cs - täällä on iso joukko taulukoita käyttäviä aliohjelmia malliksi (esim TulostaTaulukko).

Tee aliohjelma, joka tulostaa n:n kertotaulun for-silmukalla. Esimerkiksi TulostaKertotaulu(3) tulostaisi:

 1 * 3 =   3
 2 * 3 =   6
 3 * 3 =   9
 4 * 3 =  12
 5 * 3 =  15
 6 * 3 =  18
 7 * 3 =  21
 8 * 3 =  24
 9 * 3 =  27
10 * 3 =  30

Tee vielä toinen aliohjelma, joka tulostaa n:än kertotaulusta m-riviä. Toteutus while-silmukalla. Esimerkiksi TulostaKertotauluWhile(3, 5) tulostaisi:

 1 * 3 =   3
 2 * 3 =   6
 3 * 3 =   9
 4 * 3 =  12
 5 * 3 =  15

Tee sama vielä do-while -silmukalla. Mitä TulostaKertotauluDoWhile(6, 0); tulostaa, jos ei tehdä mitään erikoislisäyksiä? Mitä pitäisi lisätä?

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tehtävä 4. Rajan ylittävät

M: 15. Taulukot, 16. Toistorakenteet.

Olkoon meillä taulukko, joka sisältää int-tyyppisiä kokonaislukuja. Tee aliohjelma TulostaYli(taulukko, raja), joka tulostaa yhdelle riville taulukosta kaikki ne luvut (alkiot), jotka ylittävät annetun rajan eli tietyn luvun (yhtäsuuret eivät ylitä). Tee vastaava funktio SummaYli(taulukko, raja), joka palauttaa rajan ylittävien taulukon lukujen summan. Esimerkiksi pääohjelma

  public static void Main()
  {
      int[] luvut = { 12, 3, 5, 9, 7, 1, 4, 9 };
      TulostaYli(luvut, 4);
      int summa = SummaYli(luvut, 4);
      Console.WriteLine("Yli 4 olevien lukujen summa on: " + summa);
  }

tulostaisi

12 5 9 7 9
Yli 4 olevien lukujen summa on: 42

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tehtävä 5. Sopulit

Moniulotteiset taulukot. Et tarvitse Visual Studiota/C#:ia tässä tehtävässä. Olkoon meillä 4 x 4 matriisi (siis 2-ulotteinen taulukko):

[ 1 0 1 1 ]
[ 0 1 1 0 ]
[ 1 0 0 0 ]
[ 1 0 0 1 ]

Ykköset kuvaavat tässä "sopuleita", ja nollat ovat tyhjiä paikkoja.

Lisäksi olkoon seuraavanlainen algoritmi:

Jos ruudussa on sopuli (eli alkion arvo on 1)
  * Jos sillä on naapureita (ykkösiä) yksi tai 
    nolla kappaletta, se kuolee yksinäisyyteen 
    (muuttuu nollaksi).
  * Jos sillä on neljä tai enemmän naapureita, 
    se kuolee ylikansoitukseen (muuttuu nollaksi).
  * Sellainen, jolla on täsmälleen kaksi tai kolme 
    naapuria, selviää hengissä.
Jos ruutu on tyhjä (eli arvo on 0)
  * Jos on täsmälleen kolme naapuria, ruutu "herää 
    eloon" (muuttuu ykköseksi).

Tee yllä olevalle matriisille kolme seuraavaa "generaatiota", eli käy jokainen alkio läpi yllä annettua algoritmia käyttäen. Naapureita ovat sekä pysty-, vaaka- että "vinot" naapurit.

Tee tehtävä kahdella eri tavalla:

1. Uusi generaatio aina uuteen taulukkoon: Teet uuden tyhjän taulukon ja siihen vastinpaikkaan kuuluvan alkion arvon katsot edellisestä taulukosta em. säännöillä.
2. Kaikki generaatiot yhdessä taulukossa: Teet muutokset "lähtötaulukossa" vasemmalta oikealle, ylhäältä alas. Kun olet mennyt taulukon läpi, otat siitä "kuvan" (eli kopioit vaiheen tilanteen) ja jatkat sitten samalla taulukolla uudestaan vasemmasta yläkulmasta.

Tuleeko eri tavoilla tehtynä eri tulos? Miksi?

Kopioi alle olevaan laatikkoon alkuperäisen taulukon (sukupolvi) alle kumpaankin eri tapaan kolme uutta samankokoista taulukkoa (sukupolvea). Kirjoita taulukot allekkain. Yhteensä siis 7 taulukkoa.

Tarkista vastauksesi, onko sinulla:

• ensimmäisen tavan kolmannessa generaatiossa on vain kaksi ykköstä vinosti toisiinsa nähden
• toisen tavan kolmannessa generaatiossa on 4 ykköstä neliön muotoisessa alueessa

Tehtävä 6. Lukujen kysyminen silmukassa

M: 15. Taulukot, 16. Toistorakenteet.

Lisää tehtävään 2 kirjoittamasi aliohjelmat pääohjelman alle ja muuta pääohjelma sellaiseksi, että luvut kysytään silmukassa. Eli löydä ensi koodista riveiltä 4-9 samanlaisen toistuvat kolme koodin osaa ja korvaa ne silmukalla. Samalla tavalla kuin luennoilla tehtiin Summa-funktiossa.

L1. Liukuhihna

Dokumentissa Liukuhihna on hauska robotti. Vastaa siellä oleviin kysymyksiin. Maksimissaan voit tuolta kerätä 2.5 p. Kirjoita alla olevaan tehtävään miltä liukuhihnatehtävä tuntui ja laita itse tehtävän pisteisiin liukuhihnan tuloksesi. Saat tehdä tähän demoon sen tehtävästä osan jota et jo tehnyt aikaisemmissa, kunhan kumpaankin merkkaamasi (demo2 + demo3 + demo4 + demo5) summa on sama kuin Liukuhihnatehtävän pistemäärä.

Huom!. Pisterajatarkistus ei vättämättä toimi, joten et saa huijata laittamalla liikaa pisteitä!

B1. Lässytystä

M: 12. Merkkijonot.

Tuliko Demo 4 tehtävässä 3 isot kirjaimet huomioitua? Muuta tehtävän 3 vastausta niin, että teet funktioaliohjelman (palauttaa siis merkkijonon), jota kutsutaan seuraavasti:

string tulos = MuutaKirjaimet(jono, 'r', 'l');

Funktio muuttaa sekä isot että pienet kirjaimet (vinkki: Eli kun funktiolle tuodaan esimerkiksi 'r' ja 'l', niin se vaihtaa 'r' -> 'l' ja 'R' -> 'L'.) Funktiota käyttäen voitaisiin vanhan demon ohjelma muuttaa toimaan seuraavasti:

Toittan mitä tanot, mutta en otaa tanoa kirjainta t!
Anna teksti >Seppo tykkää jätskistä.
Tanoit tiit: Teppo tykkää jättkittä.

Ohjelma saadaan siis kahden merkin vaihtamisella toimimaan edellisen kerran tehtävän 3 vastauksena. Tehtävän TIM versiosta tietojen kysely on yksinkertaistamisen vuoksi jätetty pois, koska tarkoituksena on vaan tehdä ja testata tuota funktiota.

B2. Pistelaskuri

Alustus

Luo FysiikkaPeli projekti nimellä Pallot. Ota Demo 4:n bonus ja guru-tehtävien pallopelin mallivastaus ja korvaa sillä Pallot.cs:n sisältö.

Jos et halua ottaa kuvia käyttöön kommentoi koodista kaikki rivit, missä lukee Load ja sitten vielä rivi p.Image = kuvat[...

Jos haluat käyttää kuvia, niin mallivastauksessa käytetyt kuvat saat käyttöön seuraavasti:

• ota kuvat.zip
• pura se johonkin hakemistoon
• avaa Explorer (liekkö Oma tietokone tms.)
• mene siihen kansioon, johon purit kuvat
• katso jatko-ohjeita sisällön tuominen peliin.

Voit toki käyttää myös omia kuviasi jos haluat.

Tehtävä

Katso Jypelin ohjeista, miten lisätään pistelaskuri ja sille tapahtuma, kun pisteitä tulee tarpeeksi. Lisää pallopeliin laskuri, joka lisääntyy aina, kun saat "metsästettyä" pallon puolen välin yläpuolella. Kun 10 palloa on saatu poksautettua, lisää tähän joku onnittelu.

G1-3. GameOfLife

Tee konsoli-ohjelma, joka tulostaa vaiheittain tehtävän 5 generaatioita. Täydellisen 3-pisteen merkinnän saat, mikäli tehtävässä on myös automaattiset testit (ComTest tai NUnit) kummankin tapauksen 3:lle generaatiolle. Testaamisen helpottamiseksi tee aliohjelma (funktio), joka palauttaa 2-ulotteisen taulukon merkkijonona.

HUOM! Muutin palautusta niin, että kaikki kopioidaan tähän, myös using yms... Jos olet jo palauttanut, lisää using ja class-jutut.

PP

PP tehtävät (Pahasti Pihalla) on tarkoitettu niille, joilla on vaikeuksia aivan perusasioissa.

Tarkoitus on että nämä ovat helpompia ja kertaavia tehtäviä, joiden avulla pakollisen viikottaisen 2 pisteen saaminen on mahdollista. PP tehtävät eivät ole tarkoitettu niille, jotka ovat tehneet säännöllisesti 4 tai enemmän tehtäviä/kerta. Tekemällä kaikki PP-tehtävät voit saada enintään 1 pistettä.

PP1

Seuraava pääohjelma laskee ihmisen painoindeksin. Tee tarvittavat aliohjelmat, jotta pääohjelma toimii.

public static void Main()
{
    Console.WriteLine("Ohjelma laskee painoindeksisi.");
    string nimi = KysyNimi();
    Console.WriteLine("Hei " + nimi);
    Console.Write("Syötä pituutesi (m) muodossa x,xx > ");
    double pituus = double.Parse(Console.ReadLine());
    Console.Write("Syötä painosi (kg) > ");
    double paino = double.Parse(Console.ReadLine());
    double indeksi = LaskePainoIndeksi(pituus, paino);
    Console.WriteLine("Painoindeksisi on {0:00.00}", indeksi);
}

Vinkkejä painoindeksin laskemiseen voit katsoa luentomonisteesta

PP 2

Lataa itsellesi Tehdas.cs-tiedosto ja liitä se konsoliprojektiisi (Poista tällöin jo olemassa oleva Program.cs). Voit myös kopioida tiedoston sisällön ja korvata Program.cs-tiedoston sisällön sillä.

Tehtävänäsi on kutsua annettuja aliohjelmia oikeassa järjestyksessä sopivilla parametreillä, jotta ohjelma tulostaa "Autot lastattu onnistuneesti!". Kiinnitä huomiota erityisesti aliohjelmien paluuarvoihin sekä siihen, missä kohti kutsut mitäkin aliohjelmaa.

Demoista

Muista katsoa demo 5 palautusvideot!

HUOMAUTUS: Tällä demokerralla testejä pitää kirjoittaa itse. Malleja ja ideoita voi kopioida aikaisemmilta demokerroilta, kun niiden koodissa painaa "Näytä koko koodi".

Tässä demossa näet testien tarpeen siitä, että "Näytä koko koodi" painamalla ei näy yhtään valmista testiä. Lisäksi jos painaa Test-painiketta eikä testejä ole kirjoitettu, niin tästä tulee virheilmoitus.

Pohja, josta testejä voi kopioida (tosin tehtäviä suositellaan tehtäväksi Visual Studiossa):

    /// <summary>
    /// Aliohjelmalla ...
    /// </summary>
    /// <param name="???">?????</param>
    /// <returns>???</returns>
    /// <example>
    /// <pre name="test">
    ///   FunktioNimi(Parametrit) === tulos;
    /// </pre>
    /// </example>

Muista, että reaalilukuja testataan eri tavalla kuin muita tyyppejä!

Itsekirjoitetuista testeistä voi saada pisteitä vaikka testit olisivatkin vajavaisia, tässä pitää siis olla rehellinen! Jos testit eivät ole kunnollisia ja testaa jotakin, niin testit täytyy joko pyyhkiä pois tai tehdä sellaisiksi, etteivät ne käänny. Muuten ohjelma antaa ansiottomia pisteitä.

Täysien pisteiden saamiseksi myös dokumentaatio pitää käydä katsomassa (ja tarkistaa, että se on kunnollinen, eli siinä näkyy myös paramterin nimet ja selitykset).

Kysely 1

Vastaa kurssin välikyselyyn. Kopioi kyselystä kohta Analysoi omia vaikeuksiasi tai tarkenna edellisiä alla olevaan laatikkoon. Muista painaa return aina, kun rivi tulee täyteen, ettei tulisi yli 65 merkkiä pitkiä rivejä. Vaihtoehtoisesti paina wrap aina välillä.

Analysoi omia vaikeuksiasi kurssilla alla olevaan laatikkoon ja käy lukemassa/lisäämässä mielipiteitä palaute-sivulla. Suhteuta myös siihen, miten paljon olet käyttänyt kurssilla tarjottuja apuja, mm. pääteohjausta, keskustelukanavia, demojen harjoittelutehtäviä yms.

Video 2

Käy katsomassa videohakemistosta 3 videota, ks: videohakemisto, jotka auttavat sinua parhaiten. Kerro mistä aiheista katsoit videot ja mitä mieltä olet videohakemistolistauksesta. Jos joku video ei toimi, laita kommentti viereen tai yrittäkää korjata oikea osoite ja aika.

Tauno 1

Tee alla olevat Tauno-tehtävät. Kun saat oikeat tulokset, niin laita Taunon generoima koodi kommentteihin ja korvaa se koodilla, jossa sama asia tehdään silmukassa. Varmista Aja- ja Test-painikkeilla, että koodi edelleen toimii.

Huom 1: Tämä on "par 1" tehtävä, eli yksi apumuuttuja riittää (tarvitaan kaksi indeksimuuttujaa). Haluamasi muuttujan arvoa voit kasvattaa/vähentää yhdellä kun raahaat "laskupalkissa" olevan +1/-1 sen päälle. Olemassa olevaa muuttujaa voit käyttää indeksinä raahaamalla sen taulukon solun alla olevaan laatikkoon. Mikäli haluat käyttää toista indeksimuuttujaa, tulee sinun raahata toinen muuttuja toisen taulukon solun alle.

Huom 2: Tämän hetken Taunossa on sellainen bugi, että indeksit eivät saa mennä päistä ylitse ja jos menee, se ei näy "kuvassa".

Tauno 2*

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Tehtävää ei tehdä oikealla Taunolla mutta periaatteessa samalla idealla. Ongelma: Edellisen kerran "sopuli-pelin" tietyn sopulin naapurit voidaan laskea ehtolauseen sijaan ainoastaan summaamalla kussakin naapuriruudussa olevat luvut yhteen, ja mikäli ruuduissa on vain arvoja 0 tai 1. Tämä tarkoittaa jokaista laskettavaa ruutua kohti 8 naapuriruudun arvojen summaamista. "Matriisin" reunoilla oleville ruuduille ei VIELÄ yritetä laskea naapureiden määrää, koska reunoilla olevin naapuriruutujen määrä vaihtelee. Tehtävässä siis lasketaan naapureiden määrä vain niille ruuduille, joilla on 8 naapuriruutua.

Piirrä itsellesi kuva ruutupaperille tilanteesta, jossa "pelissä" on 6 riviä ja 5 saraketta. Kirjoita ruutuihin sopulimääriä (0 tai 1) ja ruutujen nurkkiin pienellä ruudun osoite tyyliin [1,2] (rivi ensin, sarake sitten). Kertaa itsellesi vielä, miten lasketkaan jonkin ruudun naapurisopuleiden määrän.

1. Tee alla olevan aliohjelman tehtävä taunomaisesti, eli käyttäen vain vakioindeksejä. Toisin sanoen kopioi n +=... riviä seitsemän kertaa ja muuta paikassa [1,2] olevan sopulin nurkkanaapurin indeksiparin [0,1] tilalle kullakin uudella rivillä vastaavan naapurin paikka. Mene paikat läpi rivi kerrallaan vasemmalta oikealle. Käytännössä siis kirjoita ruudun [1,2] naapureiden osoitteet (8 kpl).

2. Kopioi edellinen vastaus alle kohtaan Tauno 2.2 ja muuta vastauksesi niin, että vakioiden sijaan käytät hyväksesi aliohjelman parametreinä tuotuja indeksejä iy ja ix siten, että minkä tahansa ei-reunassa olevan ruudun naapurit voidaan laskea. Esimerkiksi tämän tehtävän kohdan 1 vastauksen 1. rivi olisi n += sukupolvi[iy-1,ix-1];. HUOM! Älä merkitse pelkkä iy vaan iy+0.

3. (Vapaaehtoinen). Kohdan 2 vastauksen jälkeen sinulla pitäisi olla 8 riviä, jotka ovat hyvin samankaltaisia, mutta eivät kuitenkaan täysin samanlaisia. Kopioi edellinen vastaus kohtaan Tauno 2.3 ja jatka sen muuttamista alla olevilla ohjeilla. Esittele apumuuttujat int x=-1, y=-1; ja muuta kaikki rivit muotoon n += sukupolvi[iy+y,ix+x]; niin, että ennen riviä muutat indeksejä x ja y siten, että seuraavalla rivillä viitataan samaan paikkaan kuin ennen muuttujien x ja y käyttämistä. Muuttamiseen saat käyttää vain lauseita x++, x=-1, y++. Älä kirjoita näitä lauseita hakasulkeiden sisään, vaan omille riveilleen.

4. (Vapaaehtoinen). Kohdasta 3 pitäisi nyt erottua kaksi sisäkkäistä silmukkaa. Tee kohtaan Tauno 2.4 kohdasta 3 uusi vastaus silmukoita käyttäen (edelleen ei reunassa oleville sopuleille).

Ville 1

Tee Ville-tehtävät: 5.6-5.8,9.4-9.6. Villen käyttöohje.

Tehtävä 1. Aliohjelman esittely

Tee seuraavia aliohjelmakutsuja vastaavat aliohjelmien tai funktioiden esittelyrivit ja aliohjelmien lyhyimmät mahdolliset rungot (eli tynkätoteutukset) siten, että aliohjelmat ovat syntaktisesti oikein (niiden ei vielä tarvitse toimia loogisesti oikein). Toisien sanoen saat koodin, joka kääntyy (ja tulostaa TIMiin OK).

Paina aluksi kussakin tehtävässä Näytä koko koodi. Koodilaatikon alla on nappuloita, joilla voit lisätä koodia. (Toistaiseksi koodia voi näillä nappuloilla lisätä vain tekstin loppuun). Jos teet tehtävää laitteella, jossa ei ole kunnollista näppäimistöä, saat poikeuksellisesti käyttää parametrien niminä a, b, c jne... Muuten pitää käyttää kunnon nimiä. Kun koodi on mielestäsi valmis, paina Aja. Jos tulee virheitä, korjaa.

Huomaa, että oikeastakin vastauksesta tulee varoituksia (warning), koska tehtävissä on muuttujia, joita siinä ei käytetä. Oikeasti varoituksiakaan ei saa tulla, mutta tässä rutiinia harjoittavassa tehtävässä ne nyt sallitaan.

Kustakin kohdasta saa 0.2 p.

Tehtävä 2*. Itseisarvo ja etäisyys

M: Liukulukujen testaaminen

M: 13. Ehtolauseet. Kirjoita ilman minkään valmiin funktion (ei esim. Math.Abs) käyttöä funktioaliohjelma jota voi kutsua muodossa

double lukuEiNegatiivisena = Itseisarvo(luku);

joka palauttaa luvun aina ei-negatiivisena, toisin sanoen sen etäisyyden nollasta. Visual Studiolla aloita kirjoittamalla sopiva testipääohjelma (tai ComTest-testit), jossa kutsut funktiota erilaisilla testattavilla arvoilla. TIM versiossakin testit pitää kirjoittaa itse.

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Mikäli tässä tai seuraavissa tehtävissä haluat käyttää jonkin toisen demotehtävän funktiota/funktoita, kopioi niiden toteutus samaan vastauslaatikkoon vaikka ilman kommentteja ja testejä. Oikeasti toki nämä linkitettäisiin käännökseen mukaan, mutta sitä ei ole kurssilla vielä opeteltu.

M: 9. Aliohjelman paluuarvo.

Tehtävä 3. Miidi ja EtsiLahin

M: 16. Toistorakenteet, 15. Taulukot. Olkoon tässä tehtävässä miidi se taulukon alkio, joka on lähimpänä taulukon alkioiden keskiarvoa. Tee funktioaliohjelma Miidi(double[] luvut), joka palauttaa reaalilukutaulukon miidin.

Esimerkki:

double[] luvut = {1, 2, 3, 2, 5};      // keskiarvo == 2.6
double m1 = Miidi(luvut);              // 3
double m2 = Miidi(new double[]{1});    // 1
double m3 = Miidi(new double[]{3, 3}); // 3
double m4 = Miidi(new double[]{});     // 0

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Voit tehdä tämän tehtävän askeleittain seuraavasti:

1. Harjoittele halutessasi lähimmän alkion etsimistä alla olevalla Tauno-tehtävällä.
2. Kopioi luentojen esimerkin Summa-funktio ja tee siitä double-luvuilla toimiva versio. Tämän avulla voit laskea keskiarvon.
3. Tee ja testaa funktio public static double EtsiLahin(double[] t, double luku) joka etsii annetusta taulukosta lähintä lukua ja palauttaa sen. Katso lähimmän etsimiseen ideaa Pienin ja Suurin -esimerkistä.
4. Lopuksi Miidi syntyy keskiarvon ja lähimmän etsimisellä parilla rivillä.

Tehtävä 4. Pisteiden välinen etäisyys

M: 9. Aliohjelman paluuarvo. Muistele koulusta (tai katso Wikipediasta), miten laskettiin suorakulmaisen kolmion hypotenuusa Pythagoraan kaavalla. Päättele, miten tämän tiedon avulla voit laskea 2-ulotteisella tasolla olevan kahden pisteen välisen etäisyyden. Kuvan piirtäminen paperille kannattaa.

Kirjoita sitten funktio

double Etaisyys(double x1, double y1, double x2, double y2)

joka laskee kahden pisteen p1 ja p2 (missä p1=(x1,y1) ja p2=(x2,y2)) välisen euklidisen (eli tuon meidän parhaiten ymmärtämän) etäisyyden.

Tehtävä 5. Reaalilukujen vertaaminen

M: 13. Ehtolauseet. Reaalilukuja ei (erittäin harvoja erikoistilanteita lukuun ottamatta) saa verrata == -operaattorilla.

Samat–funktion ideana on siis se, että jos kaksi lukua ovat "riittävän" lähellä toisiaan, palautetaan true, muuten false. Esimerkissä "riittävän" on 0.01 ja 0.2. Jos tarkkuutta ei anneta, silloin käytetään esimerkiksi 0.00001 tai muuta pientä lukua. Huomaa, että toinen kutsu on vähemmillä parametreillä kuin muut. Funktio Samat on siis ns. kuormitettu funktio (function overloading).

Tehtävä 6. Skaalaa

M: 9. Aliohjelman paluuarvo.

Tee funktioaliohjelma Skaalaa(double luku, double min, double max) joka skaalaa välillä [0, 1] olevan luvun välille [min, max]. Esimerkkejä kutsuista näet kun klikkaat Näytä koko koodi.

Tehtävä B1. Matriisin suurin

Tehtävä B2. Suhteellisesti samat

M: 13. Ehtolauseet: Tehtävässä 5 vertailtiin lukujen absoluuttista suuruutta. Kuitenkin esimerkiksi 1000 ja 1100 ovat samoja 10% tarkkuudella, mutta eivät 0.1:n tarkkuudella. Usein voikin olla järkevä puhua suhteellisesta yhtäsuuruudesta absoluuttisen yhtäsuuruuden sijaan.

B3. GameOfLife

Tehdään edellisen demokerran sopulipelistä uusi graafinen versio, jossa on paljon ruutuja (suuruusluokkaa 60 y-suunnassa) ja sukupolvia lasketaan 0.1 sekunnin välein.

Voit kokeilla tavoiteltua lopputulosta (jossa mukana myös Guru-tehtävien toiminnot, bonustehtäväksi riittää, että näytössä pyörii sukupolvia alkuperäisen arvonnan mukaan) seuraavasti:

1. Hae bin hakemiston kaikki tiedostot johonkin hakemistoon.
2. Avaa GameOfLife.txt ja lue siitä käyttöohje. Kuuntele mahdollisesti samalla luennon 12 vastaavan tehtävän selitykset.
3. Käynnistä GameOfLife.exe ja käytä ohjeiden mukaan. Tämä .exe toimii vain osassa Windowseissa (XNA asennettu), muut (ja Win myös) voivat kokeilla samoilla ohjeilla JavaScript-versiota.

Oman graafisen version tekeminen:

1. Luo uusi Fysiikka-peli nimelle GameOfLife.
2. Kirjoita luokkaan alla oleva koodi
3. Lisää projektiin edellisen demokerran Sopulit.cs:
   • kopioi tiedosto samaan paikkaan kuin projektin muut .cs tiedostot
   • Solution Explorerissa paina hiiren oikeata projektin nimen päällä
   • Add/Existing Item
   • valitse lisättävä tiedosto ja Add
   • lisää omaan .cs tiedostoon alkuun (tässä esimerkissä)

   using Demo5;

   tällöin kääntäjä tietää, että esim kutsut:

   Sopulit.Arvo(sukupolvi, 0, 1);
   Demo5.Sopulit.Arvo(sukupolvi, 0, 1);

   ovat samoja.

4. Ideana on, että luodaan näyttöön suuri määrä mustia neliöitä (oliot-taulukko). Kun on uuden sukupolven aika, lasketaan uusi sukupolvi valmiilla demo5:n aliohjelmalla. Sitten sukupolvi-taulukon mukaisesti käydään muuttamassa jokaisen vastaavassa paikassa olevan neliön väri mustaksi tai valkoiseksi.
5. Täydennä aliohjelmat (ja metodit) em. tavalla.

Koodipohjaa uudelle pelille:

H1. Harjoitustyöhön jokin viikon luentoihin liittyvä ominaisuus

Jatkossa on aina tehtävä H1, josta voi merkitä itselleen 1-2 p sen mukaan, miten sen "vaikeus" suhteutuu muihin tehtäviin.

Lisää harjoitustyöhösi (se voi olla aluksi hyvinkin tyhjä "lumiukkopohja") jokin kurssiviikon aiheeseen liittyvä ominaisuus. Kommentoi koodiin selvästi, missä "viikon" ominaisuutta on käytetty. Tällä viikolla esimerkiksi silmukat, taulukot ja 2-ulotteiset taulukot.

Jos harjoitustyöhön ei ominaisuutta saa lisättyä, voit tehdä myös pienen muun ohjelman, jossa harjoittelet ko. ominaisuuksia, mikäli varsinaisista tehtävistä ei mieleistä vastaavaa harjoittelua löydy.

Pyydetty linkki esim. muodossa:

https://svn.cc.jyu.fi/srv/svn/ohj1-pelit/2018s/oma_kayttajatunnus/

G1. Parannettu GameOfLife

Täydennä GameOfLife (ks. B3) siten, että voit Delete-napista tyhjentää kentän ja sitten hiirellä klikkailla päälle ja pois ruutuja. Hiiren klikkaus pysäyttää aina animaation ja sitten voi rauhassa rakentaa haluamansa kuvion (ks: Bitstorm ja Wikipedia) ja sitten laittaa Enter-nappulalla animoinnin uudelleen käyntiin. Välilyönti arpoo kokonaan uuden alkutilanteen.

G2. Toiston poisto

StringFormat.cs-esimerkissä on paljon copypaste-koodia. Muotoiluesimerkin muuttaminen vaatisi paljon muutoksia koodiin, samoin esimerkkinumeroiden. Tee ohjelma, jossa on yhdessä taulukossa muotoiluesimerkit ja toisessa käytetyt numerot ja sitten itse ohjelman (mahdollisten aliohjelmien kanssa) toteutus perustuu vain näiden kahden taulukon käyttöön. Nyt muotoiluesimerkin muuttaminen on vain yksi muutos yhdessä paikassa. Samoin kuin yhden esimerkkinumeron muuttaminen tai jopa lisääminen.

PP 1

PP-tehtävät on kertaavia tehtäviä.

M: 16. Toistorakenteet.
Taulukoita.cs - täällä on iso joukko taulukoita käyttäviä aliohjelmia malliksi (esim TulostaTaulukko).

Tee aliohjelma, joka tulostaa lukujen neliöitä seuraavan esimerkin mukaisesti:

 1 * 1  =   1
 2 * 2  =   4
 3 * 3  =   9
 4 * 4  =  16
 5 * 5  =  25
 6 * 6  =  36
 7 * 7  =  49
 8 * 8  =  64
 9 * 9  =  81
10 * 10 = 100

PP 2

M: 12.7 Char-luokka, 16. Toistorakenteet.

Tee aliohjelma, joka tulostaa parametrina annetusta merkkijonotaulukosta vain ne sanat, jotka alkavat isolla alkukirjaimella.

Esimerkiksi taulukosta

["kissa", "Kana", "Koira", "hevonen", "Vuohi"]

Tulostuu vain

Kana, Koira, Vuohi

C#-syntaksi

Onko kielen syntaksi hakusessa. Muista pitää vierellä auki:

• C#-pikasyntaksi

Testaamisesta

• katso esimerkkejä testaamisesta

Tämän kerran tehtävät vaikuttavat pitkiltä, mutta itse asiassa vastausten itse kirjoitettujen rivien lukumäärä tulee olemaan kurssin lyhimpiä. Eli lue tehtävät huolella ja keskity, tehtävät eivät ole niin vaikeita kuin tehtävien pituudesta voisi päätellä. Tehtävät 5, 6, ja B1 ovat muuten kanssa helppoja tehtäviä.

Muista tarvittaessa monisteen täydennyssivut! (ylälinkissä kohdassa lisämateriaali).

Kysely 1

Käy lukemassa mitä demo 6:sta kerättiin kurssin palautteeseen palaute-sivulta ja osallistu siellä keskusteluun.

Jos et vastannut demo 6:ssa, niin vastaa kurssin välikyselyyn (ei kesän kurssilla). Kopioi kyselystä kohta Analysoi omia vaikeuksiasi tai tarkenna edellisiä alla olevaan laatikkoon. Muista painaa return aina kun rivi tulee täyteen ettei tule yli 65 merkkiä pitkiä rivejä. Tai paina wrap aina välillä. Jos kirjoitit jotakin uutta, jota ei ole palaute-sivulla käsitelty, niin kopioi vastauksesi tai osa siitä palaute-sivulle

Pisteen tästä tehtävästä saavat merkitä ne, jotka eivät käyttäneet sitä demo 6:n vastaavassa kohdassa.

Ville 1

Muista että jos et tykkää Villestä, näitä ei ole pakko tehdä.

Tee Ville-tehtävät: 5.9-5.13,9.8 Villen käyttöohje

Jeliot 1

Tämäkään ei ole pakollinen, mutta voi olla hyvä havainnollistus jollekin! Vajaasta 30:stä tässä (syksy 2018) demossa kokeilleelta on tullut palautetta että oli hyötyä!

Ota itsellesi Jeliot.jar, eli ota tuo .zip, pura jonnekin ja käynnistä syntynyt Jeliot.jar. Copy/Paste koodialueelle Kutsuminen.java (vertaa Kutsuminen.cs, jollet ole nähnyt kutsunäytelmää, niin katso se samalla kun teet tätä). Nyt sinun on tarkoitus Jeliotilla katsella sama asia parametrin välityksestä, mikä oli kutsunäytelmässä. Kun koodi on koodialueella, paina Compile ja sen jälkeen lähde ajamaan ohjelmaa askel kerrallaan ja mieti ajatuksen kanssa mitä missäkin kohti tapahtuu. Vaikka esimerkkikoodi on Javaa, kaikki tapahtuu täsmälleen samalla tavalla C#:issa. Kerro mitä opit tästä ja/tai kutsunäytelmästä.

Pohjatiedosto varsinaisille tehtäville

Pohjana käytetään tiedostoa Kuvaaja.cs. Tehtävät 1-4 perustuvat tämän muuttamiseen ja täydentämiseen. Tehtävät 1, 2 ja 3 pystyy tekemään suoraan TIMissäkin, mutta ainakin tehtävä 4 vaatii Visual Studiossa Kuvaaja.cs:n muokkaamista.

Voit ottaa pohjan kahdella eri tavalla (suosittelen ensimmäistä, Windows, Mac, Linux):

Versionhallinnan tapa valmiille projektille:

• seuraavan voi tehdä joko komentoriviltä, eli mene ensin komentorivillä demohakemistoosi ja

  svn export https://svn.cc.jyu.fi/srv/svn/ohj1/esimerkit/2018s/demopohjat/demo7

  Mäc käyttäjät hakevat lisäksi oman projektinsa kirjoittamalla samassa hakemistossa

  svn export https://svn.cc.jyu.fi/srv/svn/ohj1/esimerkit/2018s/demopohjat/demo7Mac/

  Mäcissä huomaa että demo7 ja demo7Mac pitää tulla rinnakkaisiin hakemistoihin, koska demo7Mac käyttää demo7 hakemistossa olevia .cs -tiedostoja suhteellisen polun avulla.

  Xamarin 5.1 käyttäjät (Linux) hakevat lisäksi:

  svn export https://svn.cc.jyu.fi/srv/svn/ohj1/esimerkit/2018s/demopohjat/demo7x51/

• tai TortoiseSVN:llä:

  • siirry Explorerilla (siis ei IE vaan se Tiedostonhallinta-juttu) johonkin tyhjään hakemistoon

  • paina Explorerissa hiiren oikeaa

  • valitse TortoiseSVN/Export... (nimenomaan Export eikä Checkout ettet pilaa pohjaa muilta :-)

    • jos käyttää Mäkissä SmartSVN:ää, niin Checkout-kohdan alta löytyy ruksi Export.

  • URL of repository: -kohtaan laita

    https://svn.cc.jyu.fi/srv/svn/ohj1/esimerkit/2018s/demopohjat/demo7

  • OK

• kun tavara haettu,

  • Windows: klikkaa demo7.sln hiiren oikealla, valitse Open with/Microsoft Visual Studio 2017
  • Mäc: siirry demo7Mac ja klikkaa demo7Mac.sln
  • Linux: siirry demo7x51 ja klikkaa demo7x51.sln

• solutionissa on monta projektia. Muista aina hiiren oikealla ja Set as StartUp Project valita minkä projektin haluat ajaa (pitää näkyä boldina).

• tällä tavalla saat myös Taunot ja AngryLegot pohjaksi samalla vaivalla.

• katso luennon 13 esimerkeistä miten ne muutettaisiin Macille (tämä siis tehty valmiiksi projektissa demo7mac)

HUOM: Mäcissä ajettaessa testejä voi joutua ekan kerran jälkeen tekemään sen, että kaikissa tai osassa Test-loppuisissa projekteissa käy Packages-kohdasta poistamassa NUnit-viitteen ja sitten lisäämässä sen takaisin.

Tauno 1

Toteuta a-kohdassa Taunolla tekemäsi koodin pohjalta funktioaliohjelma

MuutaYli(int[] t, int raja, int miksi)

joka muuttaa taulukosta kaikki annetun rajan ylittävät alkiot miksi-parametrissa annetuksi arvoksi ja joka palauttaa muutettujen alkioiden lukumäärän.

Tauno 2

Matriisin sisätulo: kerrotaan kahden matriisin vastinalkiot keskenään ja lasketaan tulot yhteen. Tässä tehtävässä lasketaan maskimatriisin ja varsinaisen matriisin osamatriisin sisätulo. Alla olevassa kuvassa hvainnollistettu tilannetta, jossa varsinaisesta matriisista otetaan indeksin [2,1] ympärillä oleva maskin kokoinen osamatriisi.

Tässä voi olla myös hyötyä tehdä valmiiksi etukäteen Demo 8:n B1 tehtävä, tätä varten katso avuksi videot:

Matriisi:

Maski:

Yllä olevan kuvan tapauksessa sisätulo olisi:

35*1 +  50*1 +  60*1 + 
50*1 +  90*1 + 102*0 + 
20*0 +  34*1 +  44*1     = 363

Kun yllä olevassa kuvassa laitat maskin johonkin kohti, näet missä indekseissä olevat luvut kerrotaan keskenään ja summataan. Huomaa että maskin indeksit eivät riipu siitä, mihin kohti matriisissa se laitetaan.

Tätä tehtävää ei tehdä oikealla Taunolla, mutta periaatteessa samalla idealla. Ongelmana on tällä kertaa matriisin sisätulon laskeminen. Eli lyhyesti sanottuna otetaan kahden matriisin vastaavissa paikoissa olevat alkiot ja kerrotaan ne keskenään ja lasketaan näiden tulojen summa. Itse asiassa Sopulipelin ja sen harjoittelutehtävän naapurien määrän laskeminen olivat sisätuloja, joissa maski-matriisina olivat

1 1 1          0 1 0
1 0 1          1 0 1 
1 1 1          0 1 0

1. Tee alla olevan aliohjelman tehtävä taunomaisesti, eli käyttäen vain vakionumeroita (lisättävä 6 riviä valmiiseen koodiin). Tehtävänä siis laskea mallimatriisin pisteen [2,1] ympärille tulevan 3x3 osamatriisin ja maskin sisätulo, eli kertoa vastinalkiot keskenään ja laskea tulot yhteen. Vrt. Demo 6 Tauno 2. Huom. Nyt "keskipiste" ei ole mikään erikoistapaus.

2. Kohtaan Tauno 2.2 muuta vastauksesi niin, että käytät hyväksesi indeksejä ix, iy vakioiden sijaan niin, että minkä tahansa ei-reunassa olevan osamatriisin sisätulo voidaan laskea. Eli aloita vaihtamalla [2,1] tilalle [iy+0,ix+0] ja muihin vastaavasti.

3. (Vapaaehtoinen) koita tehdä sama silmukalla

Tehtävä 1*. Pisteet taulukossa

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Vaikka tehtävät 1-3 voikin tehdä suoraan TIMissä, suositellaan niiden tekoon ehdottomasti Visual Studion tms käyttöä. Pohjamateriaaleissa tehtävät on merkitty TODO:-kommenteilla.

Huomasithan ottaa ensin pohjatiedostot! Tehtäviin 1-4 kannattaa malliksi katsoa luennolla 14 tehty LaskeMatka.cs .

M: 15. Taulukot.

Täydennä Kuvaaja.cs:n aliohjelma LuoPisteet toimivaksi niin, että se piirtää (=lisää) parametrina tuodun pisteet-taulukon koordinaattipisteitä (=vektoreita, eli Jypelin X,Y-lukupareja) vastaaviin paikkoihin mustat pikkupallot näytölle (=peliin).
Yritä ensin piirtää vaikka vain taulukon paikassa 0 olevaan pisteeseen pallo ja kun se onnistuu, niin sulje tuo piirto silmukkaan, joka käy kaikki pisteet taulukon pisteet läpi.

Esimerkiksi paikassa 2 olevan pisteen (vektorin) kohdalle saisit keltaisen pallon valmiilla alempana olevalla funktiolla:

  LuoPallo(game,pisteet[2],r,Color.Yellow);

Kun tehtävä on tehty, "peliin" pitäisi tulla 4 mustaa pistettä (koska tehtävän 2 ArvoPisteet toistaiseksi "arpoo" vain 4 pistettä) kun sen ajaa.

Tehtävä 2*. Arvo pisteet

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

Korjaa Kuvaaja.cs:n funktioaliohjelma ArvoPisteet, joka luo parametrin n arvon kokoisen taulukon ja arpoo tason pisteitä taulukkoon (Vector[] pisteet). Arvo RandomGen-luokan NextDouble-funktiota käyttäen x ja y-koordinaatit ja luo aina vastaava uusi Vector. (Esimerkki käytöstä oli mm: Pallot.cs). Nyt ohjelman ajossa pitäisi koordinaatistoon tulla 20 pistettä satunnaisiin paikkoihin.

HUOM: Tässä tehtävässä tarvitset Tehtävässä 1 tekemääsi LuoPisteet-aliohjelmaa. Kopioi aliohjelman toteutus edellisestä tehtävästä tämän tehtävän koodiin

Vinkki: Tutki ensin aliohjelman nykyistä toteutusta (tekee väkisin 4 vektoria) ja mieti miten sama tehdään silmukassa.

Tehtävä 3. Lähin piste

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

M: 15. Taulukot, 16. Silmukat.

Täydennä funktioaliohjelma LahimmanIndeksi, joka etsii annettua pistettä lähimmän taulukon alkion indeksin.

Näissä tehtävissä ei ole Näyta koko koodi, koska tarvitaan tulevien tehtävien vastauksia. Koodin ympärillä on kuitenkin valmiiksi tarvittavat luokat ja puuttuvat aliohjelmat, eli vastauslaatikkoon tulee vain LahimmanIndeksi-funktion toteutus, kommentit ja testit. Ei pääohjelmaa tms.

Kun tämän tehtävän ajaa TIMissä, arvotaan aluksi 20 mustaa pistettä. Sitten arvotaan siniselle pisteelle satunnainen paikka. Sitten etsitään sinistä pistettä lähimmän pisteen paikka ja sen päälle laitetaan punainen piste.

Tehtävä 4. Lähimmän merkitseminen

Nyt metodi (se on metodi, koska se tarvitsee muitakin peli-olion asioita kuin parametrina tuodut) public void SiirraMerkkipisteet(Vector p) jota kutsutaan kun hiirtä klikataan (ks. Mouse.Listen -rivit), siirtää vain sinisen pisteen (klikattuPiste) hiirellä klikattuun kohtaan. Täydennä metodia siten, että se etsii pisteet-taulukosta lähimmän koordinaatin indeksin ja siirtää punaisen merkkipisteen tätä indeksiä vastaavaan koordinaattiin.

pisteet-taulukko näkyy metodille, koska taulukko on peli-luokan attribuuttina. Siksi sitä ei ole tässä tapauksessa tuotu parametrina kuten on tehty staattisissa metodeissa. Tätä metodia ei siksi voisi kutsua muista ohjelmista ilman peliluokan olemassaoloa. Samoin SiirraMerkkipisteet-metodi näkee myös attribuutit klikattuPiste ja merkkipiste.

HUOM: Tätä tehtävää et voi tehdä pelkästään TIMissä, vaan tätä varten pitäisi hakea pohjatiedostot Visual Studioon (tai vastaavaan) muokattavaksi. Ks. Ohjeet

Tehtävä 5. Kirjainten laskeminen

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

M: 16. Silmukat. Tee funktio LaskeKirjaimet, joka laskee merkkijonossa olevien annetun kirjaimen esiintymien lukumäärän.

Funktiota voitaisiin kutsua muodossa

int kMaara = LaskeKirjaimet("kissa", 's');

Kirjoita funktiolle myös ComTest-testit

Tehtävä 6. Matriisien summa

Jos yhtään vaikeuksia summassa, katso: tehtävä jolla voi harjoitella.
Jos yhtään vaikeuksia matriisin palauttamisessa, katso: tehtävä jolla voi harjoitella.

M: 15.5 Moniulotteiset taulukot, 16. Silmukat. Tee funktioaliohjelma, joka summaa yhteen kaksi matriisia vastinalkioittain. Funktio siis joutuu ensin luomaan oikeankokoisen tulosmatriisin. Mitä on syytä olettaa parametrimatriiseilta? Dokumentoi kommentteihin oletuksesi. Sitten funktio laskee tulosmatriisiin komponenteittain summan.

Funktioaliohjelmaa voitaisiin käyttää esimerkiksi näin:

public static void Main(String[] args)
{
    double[,] mat1 = {{1,2,3}, {2,2,2}, {4,2,3}};
    double[,] mat2 = {{9,2,8}, {1,2,5}, {3,19,-3}};
    double[,] mat3 = Summa(mat1, mat2);
}

Ja tässä summamatriisi mat3 näyttäisi tältä:

{{10,  4, 11}, { 3,  4,  7}, { 7, 21,  0}}

Summamatriisi voitaisiin tulostaa myös Demo 6 Jonoksi funktion avulla seuraavalla ohjeella.

B1. Lukujen erottaminen merkkijonosta

• MjPilkkominen.cs

M: 17. Merkkijonojen pilkkominen ja muokkaaminen

Merkkijonojen pilkkominen: Tee funktioaliohjelma ErotaLuvut(String jono), jonka ansiosta seuraava pääohjelma

public static void Main(String[] args)
{
        double[] luvut = ErotaLuvut("2.23 3 4 5 k      9 ;5");
        Console.WriteLine(String.Join(" ", luvut));
}

tulostaisi

 2.23  3  4  5  0  9  5

Huom! Tehtävää ja sen testaamista voi vaikeuttaa se, että eri maissa ja koneiden asetuksissa käytetään eri desimaalimerkkiä. TIMissä ajettaessa käytetään desimaalipistettä.

Tälle eräs hyötykäyttö on esimerkin Kuvaaja.cs metodissa KysyKoordinaatti, jota kutsutaan jos painetaan hiiren oikeata nappia. Tällöin kysytään käyttäjältä pisteen koordinaatti ja luodaan uusi vihreä pallo ko. kohtaan. Ohjelman puhelinversiossa sama kysytään kun pyyhkäistään näyttöä ylhäältä alas.

B2. if-lauseiden poisto

M: 13. Ehtolauseet, 15.5 Moniulotteiset taulukot, 16. Silmukat.

Demo 5:n mallivastauksessa Sopulit.cs on funktio LaskeNaapurit kirjoitettu seuraavasti:

public static int LaskeNaapurit(int[,] sukupolvi, int rivi, int sarake)
{
    int summa = 0;
    int maxy = Math.Min(sukupolvi.GetLength(0) - 1, rivi + 1);
    int maxx = Math.Min(sukupolvi.GetLength(1) - 1, sarake + 1);
    for (int iy = Math.Max(0, rivi - 1); iy <= maxy; iy++)
        for (int ix = Math.Max(0, sarake - 1); ix <= maxx; ix++)
        {
            if (iy != rivi || ix != sarake) // itseä ei lasketa naapuriksi
                if (sukupolvi[iy,ix] > 0) summa++;
        }
    return summa;
}

Tarkoituksenahan on mennä periaatteessa edeltävä rivi, oma rivi ja seuraava rivi ja niissä edeltävä sarake, oma sarake sekä seuraava sarake unohtaen kuitenkin oma koordinaatti. Eli jos rivi=2 ja sarake=1, niin pitäisi käydä ruuduissa

(1,0),(1,1),(1,2)
(2,0),      (2,2)
(3,0),(3,1),(3,2)

On kuitenkin hieman työlästä kirjoittaa silmukka, jossa jokaista riviä ei käsiteltäisi samalla tavalla, siksi em. esimerkissä käydään silmukoilla myös ruudussa (2,1). Ja jos silmukat tuovat tämän koordinaatin, niin se on if-lauseella ohitettu. Mikäli tutkittava ruutu ei ole reunalla, niin periaatteessa em ruudut saataisiin käytyä läpi seuraavalla alustuksella:

    int alkuy = rivi - 1;
    int loppuy = rivi + 1;
    int alkux = sarake - 1;
    int loppux = sarake + 1;
    // Tähän rajojen korjaus
    for (int iy = alkuy; iy <= loppuy; iy++)
        for (int ix = alkux; ix <= loppux; ix++)
        {...

Reunojen kanssa on kuitenkin ongelmana indeksialueen ylitys. Siksi mallivastauksessa yläraja maxy on laskettu niin, että se on pienempi luvuista rivi+1 tai viimeisen rivin indeksi (rivimäärä-1). Sama sarakkeen tapauksessa maxx. Alaraja on vastaavasti suurempi luvuista rivi-1 tai 0. Pienenä miinuksena mallissa on se, että tuo Math.Max-funktio kutsutaan jokaisella rivillä uudelleen, vaikka se tuottaa joka kerta saman arvon.

Tehtävä 1: korjaa edellä olevat alkuy, loppuy, alkux, loppux if-lausetta käyttämällä ennen silmukoita oikeiksi niin, että tuo silmukka voi aina olla:

    for (int iy = alkuy; iy <= loppuy; iy++)
        for (int ix = alkux; ix <= loppux; ix++)

Mallivastauksen toinen "vika" on se, että ehtolause:

            if (iy != rivi || ix != sarake) // itseä ei lasketa naapuriksi

on silmukan jokaisella kierroksella ja sitä tarvitaan vain yhdessä tapauksessa noista yhdeksästä kierroksesta. Jos tutkittavia pistetä on vaikka 100x100, niin suoritetaan 90 000 if-lausetta.

Toisaalta myös toinen if-lause

  if (sukupolvi[iy, ix] > 0) summa++;

on turha jos oletetaan että taulukossa on vain lukuja 0 tai 1 (miten tehdään?).

Tehtävä 2: muuta silmukan sisäosa sellaiseksi, että siinä ei ole yhtään if-lausetta, mutta silmukoiden jälkeen korjataan mahdollisesti liian paljoksi lasketut naapurit (ruudun itsensä takia laskettu). Tähänkään ei tarvita if-lausetta em oletuksilla.

B3. Suljettu GameOfLife

Torus on pinta (munkkirinkilän kuori), joka tulee kun esim paperi laitetaan rullalle ja syntyneen sylinterin päät yhdistetään. GameOfLifen matriisi voidaan kuvitella kirjoitetuksi tällaiselle pinnalle.

Tee tehtävään B2 funktio LaskeNaapuritTorus, joka laskee naapurit niin, että jos mennään reunalta yli, tullaan toiselta laidalta takaisin. Koodi on lähes sama kuin tehtävässä B2, mutta se voidaan tehdä täysin ilman if-lauseita.

Kokeile miltä GameOfLife näyttäisi tällä versiolla.

B4-5. AngryLego

Kun otat pohjatiedostot TortoiseSVN:llä ohjeiden mukaan, saat myös AngryLego -pelin.

Jos AngryLego antaa korkearesoluutioisella näytöllä poikkeuksen

System.NotSupportedException' "XNA Framework Reach profile supports a maximum Texture2D size of 2048.

niin ongelma korjaantuu Visual Studiossa:

  Solution Explorer/Angry Lego/Hiiren oikea/Properties/XNA Game Studio/Game profile:

kohdasta vaihtamalla radiopainikkeen kohdasta

Use Reach.. -> Use HiDef...

Mikäli paliealue ei näy kunnolla, niin muuta riviin:

 Camera.ZoomToLevel();
 

sulkuihin sopiva marginaali, esim 100.

Tehtävänä lisätä peliin:

• siirrä kaikki kuvien lataukset olion attribuuteiksi ja siellä missä kuvaa tarvitaan, käytä tätä attribuuttia: private Image pallonKuva = LoadImage("Igor"); ... pallo.Image = pallonKuva; näin saat niin, ettei kuvia ladata kuin kerran ja voidaan käyttää samoja kuvia.

• pallot elävät vain max. 5 sekuntia

• pelissä voi pudottaa vain 10 palloa (voitava muuttaa yhdestä paikkaa koodista joksikin muuksikin)

• pistelaskuri, pallon osumasta viholliseen saa 100 pistettä ja seinän takia räjähtäneestä vihollisesta 50 pistettä.

• välillä syntyykin räjähtäviä Symbian-kännyköitä (paineaalto mukana)

Vinkki: Lue Jypelin ohjeet

Jos teet samoja ominaisuuksia omaan peliin, saat merkitä tämän tehtävän. Vastaavasti G2 ja G3 kohdalla.

H1-2. Harjoitustyöhön joku viikon luentoihin liittyvä ominaisuus

Jatkossa on aina vapaaehtoinen tehtävä H1, jolla voi korvata muita tehtäviä mikäli harjoittelee samaa osaamistavoitetta kuin varsinaisissa tehtävissä tai Bonus-tehtävissä.

Lisää harjoitustyöhösi (se voi olla aluksi hyvinkin tyhjä "lumiukkopohja" jokin kurssiviikon aiheeseen liittyvä ominaisuus. Kommentoi koodiin selvästi missä "viikon" ominaisuutta on käytetty. Tällä viikolla esimerkiksi merkkijonon pilkkominen, silmukat, taulukot ja 2-ulotteiset taulukot.

Jos harjoitustyöhön ei ominaisuutta saa lisättyä, voit tehdä myös pienen muun ohjelman, jossa harjoittelet ko. ominaisuuksia mikäli varsinaisista tehtävistä ei mieleistä vastaavaa harjoittelua löydy.

Pyydetty linkki esim. muodossa:

https://svn.cc.jyu.fi/srv/svn/ohj1-pelit/2018s/oma_kayttajatunnus/

Mikäli teit toisenkin lisäyksen harjoitustyöhön, laita muutos seuraavaan laatikkoon.

G1. Säännöt taulukkoon

M: 15.5 Moniulotteiset taulukot.

Nyt GameOfLife on säännöillä b3s23 (born 3, stay 2 ja 3, ) eli synnytään 3:lla naapurilla ja pysytään 2:lla tai 3:lla naapurilla. Muuta Sopulit.cs:n SeuraavaSukupolvi - aliohjelma sellaiseksi, että sille voidaan viedä jonkinlaisena taulukkona säännöt ja silmukoiden sisään ei tule enää yhtään if-lausetta (viisastelijoille: myös ?-lause on if-lause, samoin switch :-)

G2. Osuminen laskeminen

Lisää AngryLegoon:

• yksittäinen seinä- tai kattoelementti räjähtää pois, jos siihen tulee 4 osumaa pallosta

• Vinkki: Perintä

G3. Uusi kenttä

Lisää AngryLegoon:

• jos kentän kaikki viholliset tuhottu, tulee uusi erilainen kenttä.

• Kun 3 kenttää pelattu, peli päättyy ja tulee "TopTen"-lista.

PP1

Tee aliohjelma, joka kopioi annetun taulukon alkioittan uuteen taulukkoon. Tee myös aliohjelma, joka kopioi taulukon alkioit uuteen taulukkoon mutta kääntäen siten, että ensimmäinen alkio menee uuden taulukon viimeiseksi alkioksi, toinen alkio uuden taulukon toiseksi viimeiseksi jne.

Vinkki: Taulukot, M: 15. Taulukot ja M: 16.4 for-silmukka

PP2

Tee funktio(aliohjelma) LaskeMerkkijonot, jolle annetaan parametrina merkkijonotaulukko, sekä etsittävä merkkijono. Funktio laskee, kuinka monta etsittävää merkkijonoa taulukosta löytyi.

Vinkki: Taulukot, M: 15. Taulukot ja M: 16.4 for-silmukka ja M: 13.2 if-rakenne

TÄRKEÄÄ: Kokeeseen ilmottautuminen

Korpissa on kurssin sivulla ilmoitettu kurssin tentit. Käy ilmottautumassa tenttiin ja lukemassa tarkemmat ohjeet tentin järjestelyistä tentti-sivulta.

Kysely 1 / Vaikeaa

Mikäli vastaisit jo demossa 6 tai 7 tehtävään Kysely 1, saat tästä pisteitä jos osallistut keskusteluun välikyselyn vastauksista on kerättyn synteesiin tuonne palaute-sivulle. Tarkoitus on että siellä jokainen voi osallistua lisää keskusteltuun ja jos löydettäisiin kipukohtiin jotakin yhteisiä lääkkeitä. Tässä tapauksessa kirjoita alle mitä laitoit keskusteluun.

Mikäli et vielä ole vastannut, vastaa kurssin välikyselyyn. Kopioi kyselystä kohta Analysoi omia vaikeuksiasi tai tarkenna edellisiä alla olevaan laatikkoon. Muista painaa return aina kun rivi tulee täyteen ettei tule yli 65 merkkiä pitkiä rivejä !

Ville 1

Tee Ville-tehtävät: 6.5, 9.7 + kaksi sellaista joita et ole aiemmin ymmärtänyt kunnolla (jos kaikki ymmärretty, ei tätä ylim kahta tarvitse tehdä). Mitä 9.7:ssa on väärin C#:ia ajatellen? Muista: Villen käyttöohje.

Jeliot 1

Mikäli et tehnyt tätä demossa 7 (jos teit, ei saa uudestaan ottaa näitä pisteitä!) saat vielä tehdä tämän. Vajaasta 30:stä tässä (syksy 2018) demossa 7 kokeilleelta on tullut palautetta että oli hyötyä!

Ota itsellesi Jeliot, eli ota tuo Download Jeliot JAR. Pura .zip jonnekin ja käynnistä syntynyt Jeliot.bat. Copy/Paste koodialueelle Kutsuminen.java (vertaa Kutsuminen.cs, jollet ole nähyny kutsunäytelmää, niin katso se samalla kun teet tätä). Nyt sinun on tarkoitus Jeliotilla katsella sama asia parametrin välityksestä, mikä oli kutsunäytelmässä. Kun koodi on koodialueella, paina Compile ja sen jälkeen lähde ajamaan ohjelmaa askel kerrallaan ja mieti ajtuksen kanssa mitä missäkin kohti tapahtuu. Vaikka esimerkkikoodi on Javaa, kaikki tapahtuu täsmälleen samalla tavalla C#:issa. Kerro mitä opit tästä ja/tai kutsunäytelmästä.

TDD1

Listojen luominen testejä varten onnistuu esim. luomalla ensin taulukko ja sen avulla muodostamalla lista:

///   Vector[] t = { new Vector(1,2),new Vector(3,4),
///                  new Vector(5,2),new Vector(5,5) };
///   List<Vector> luvut = new List<Vector>(t);

tai

///   List<Vector> luvut = new List<Vector>{ 
///                  new Vector(1,2),new Vector(3,4),
///                  new Vector(5,2),new Vector(5,5) };

Pohjatiedostot varsinaisille tehtäville

Ota pohjat joko:

• valmiina demo 7 Win, Mac ja Linux projektina (Linux = demo7x51)

tai:

Tauno 1

Katso ensin video ja mallivastaus Demo 7:n Tauno-tehtävän käsittelystä. Tee Taunolla tehtävä, joka laskee pisimmän rajan ylittävien arvojen yhtenäisen osajonon pituuden taulukosta. Esimerkiksi taulukossa

7 9 8 3 10 12 11 14 5 8

on kolme yhtenäistä ehdon täyttävää osajonoa (osajono on siis tässä peräkkäisissä paikoissa olevien alkioiden jono)

7 9 8 
10 12 11 14 
8

joiden kaikkien arvot ylittävät raja-arvon 6. Näistä pisin on 4 pitkä. Oikeasti osajonoja ei tarvitse muodostaa, koska lasketaan vaan niiden pituuksia. Ja niistäkin riittää ylläpitää aina nykyisen ja tähän astisen parhaan pituutta.

Huom! "Simuloi" if lauseita tekemällä itsellesi joku apumuuttuja jota käytät "Taunon-laskukoneella" tyyliin

ifRajanYli = raja - t[i]

ja muuta sitten koodissa nämä oikeiksi if-lauseksi tyyliin

if ( raja < t[i] ) ... 

Eli tuo valmis ifRajanYli ei ole tarkoitettu laskuriksi, vaan muuttujaksi, jonka perusteella arvioidaan onko tutkittava luku rajan ylittävä. Koska Taunossa ei ole if-lauseita, näin saadaan "paikka" niihin kohti, missä vertailua pitää suorittaa. Itse tarvittavia laskureita varten tee uusia muuttujia.

Mikäli haluat tehdä suoraan silmukan, niin tee ensin b-kohdan vastaus ja kopioi se tämän ohjelmakohtaa.

Huom. ennen kuin ajat ohjelman, kopioi koodi Taunosta ja poista tämän jälkeen rivi int raja = 50; ja lisää loppuun return -rivi.

Valintakoe 2p

Tee syksyn 2016 valintakokeen ohjelmointitehtävä.

Tehtävä 1*. Karkausvuosi

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

M: 13. Ehtolauseet. Tee funktio Karkausvuosi(int vuosi), joka palauttaa 'true' jos vuosi on karkausvuosi. Seuraavassa sana vuosisata tarkoittaa katkaistua kokonaislukua joka tulee kun vuosi jaetaan sadalla. Karkausvuosia ovat neljällä jaolliset vuodet, mutta ei täydet vuosisadat paitsi neljällä jaolliset vuosisadat (esim. 1900 ei ollut karkausvuosi, 1900 on 19 sadalla jaettuna ja 19 ei ole jaollinen neljällä, mutta 20 on ja siksi 2000 on karkausvuosi). Mieti kunnon testiohjelma / ComTest-testit.

Tehtävä 2*. Vuodenajat (max 2p)

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.

M: 13. Ehtolauseet, 13.8 switch-rakenne, 16. Toistorakenteet, 15. Taulukot. Kirjoita 3 erilaista funktiota Vuodenaika(int kuukausi), joka palauttaa merkkijonona sen vuodenajan, joka parametrina vietynä kuukautena on. Yksi käyttää if-lausetta, toinen switch-lausetta ja kolmas taulukkoa.

Seuraavaan katso idea: M: Arvosana kirjalliseksi, eli tavoite on että rajatarkistusten jälkeen itse ongelma ratkeaa ilman silmukoita ja ehtoja yhdellä lausekkeella.

Tehtävä 3. Refaktorointi

Taas pitkä tehtävä, johon lyhyt vastaus (katso tehtävän luona oleva video). Tarkoitus on opetella muuttamaan toistuvaa koodia paremmaksi.

Kirjoita myös LuoPallo2 -metodi yhdellä rivillä käyttäen mallina tuota LuoPallo-metodia. Tarkista että ohjelma edelleen toimii samalla tavalla. Eli yläorrella on kaksi Igoria ja yksi Symbian kännykkä ja kun Symbian häviää, se "liekittyy" Symbianin kuvilla. Lisäksi Symbian-kännykkä ei ole neliö orrella ollessaan, vaan laihempi (suorakulmio kuten alunperinkin).

Tehtävä 4. Refaktorointi

Kuten edellisessä tehtävässä, myös rakenteiden luonnissa on toistoa (tässä ei tarvitse mitään delegaatteja tms "hankalaa"):

private PhysicsObject LuoSeina()
{
    SarkyvaRakenne seina = new SarkyvaRakenne(tileWidth, tileHeight);
    seina.Tag = "rakenne";
    seina.Kuvat = tiilenKuvat;
    return seina;
}


private PhysicsObject LuoKatto()
{
    SarkyvaRakenne katto = new SarkyvaRakenne(tileWidth * 1.5, tileHeight);
    katto.Tag = "rakenne";
    katto.Kuvat = katonKuvat;
    return katto;
}

Tee metodi LuoSarkyvaRakenne sopivilla parametreilla niin, että saat vaihdettua sekä LuoSeina että LuoKatto -metodit yhden rivin metodeiksi.

Tehtävä 5. Taulukko listaksi (helppo)

M: 23.2 Listat Vaihda taulukko listaksi. Tästä oli esimerkki luennon 15 lopussa. Eli Kuvaaja.cs:ssä vaihda

private Vector[] pisteet;

tilalle

private List<Vector> pisteet;

ja tee kaikki muut tarvittavat muutokset, jotta ohjelma toimii täsmälleen kuten aikaisemminkin.

Tehtävä 6. Kuukausien keskilämmöt

M: 23.2 Listat Muuta Kuvaaja.cs:ää siten, että se alkaa tyhjällä koordinaatistolla ja aluksi kysytään käyttäjältä merkkijono, jossa olisi tarkoitus olla vuoden kuukausien keskilämpötiloja. Merkkijonosta pilkotaan demo 7:n vastauksella reaalilukutaulukko. Sitten piirretään kuva (lisätään palloja kuvaan), siten että lukua vastaavat x-koordinaatit ovat 10,20,30 jne.

Eli jos käyttäjä antaa merkkijonon

-10 -12 5 7 14 18

niin piirretään vastaavasti pallukat paikkoihin

(10,-10)
(20,-12)
(30,5)
(40,7)
(50,14)
(60,18)

pallukoiden värit ovat niin, että yli 12 olevat pisteet ovat punaisella ja alle 0:n olevat pisteet sinisellä. Muut mustalla.

1. Aluksi muuta alueen rajat:

    private const double x1 = -1;
    private const double x2 = 70;
    private const double y1 = -15;
    private const double y2 = 25;

2. Poista pääohjelmasta:

    pisteet = ArvoPisteet(20, x1, y1, x2, y2);
    LuoPisteet(this, pisteet, pallonKoko);

3. Lisää pääohjelman (Begin) loppuun

    KysyKoordinaatti();

4. Muuta sopivasti metodin KysyKoordinaatti kysymystekstiä.

5. Muuta metodi KoordinaattiAnnettu muotoon:

    private void KoordinaattiAnnettu(InputWindow ikkuna)
    {
        string vastaus = ikkuna.InputBox.Text;
        double x = 10;
        double[] d = Demo7.Taulukot.ErotaLuvut(vastaus);
        pisteet = new List<Vector>();
        foreach (double luku in d)
        {
            pisteet.Add(new Vector(x,luku));
            x += 10;
        }
        LuoPisteet(this, pisteet, 0.3,0.0,12.0);
        kysymassa = false;
    }

Varsinaiseksi tehtäväksi jää tehdä tuo aliohjelma

 public static void LuoPisteet(PhysicsGame game, ??? pisteet, 
                              double r, double ala,double yla)

jossa ala ja yla ovat rajat sille, mitä piirretään milläkin värillä.

B1 Konvoluutio käsin (videon katsominen pakollista)

Vaikka tehtävä onkin vapaaehtoinen bonus-tehtävä, on siihen liittyvän videon katsominen pakollista, sillä tulevissa demoissa oletetaan että tiedetään mitä tarkoittaa kuvassa olevat väriarvot

Bittikuvat esitetään taulukkona, jossa on kutakin pikseliä vastaava kirkkaus numeroarvona 0-255. Esimerkiksi 7x7 harmaasävykuva jossa on mustalla pohjalla yksi valkoinen vinoristi:

----------------------------
255   0   0   0   0   0 255
  0 255   0   0   0 255   0
  0   0 255   0 255   0   0
  0   0   0 255   0   0   0
  0   0 255   0 255   0   0
  0 255   0   0   0 255   0
255   0   0   0   0   0 255
----------------------------

Kuvalle voidaan tehdä konvoluutio-muunnos sillä tavalla, että maskia, esim sumennus:

1  1  1
1  1  1
1  1  1

"liutetaan" jokaisen kuvapikselin kohdalle niin, että maskin keskipiste laitetaan vastaavan kuvapikselin kohdalle.

Kunkin "liutus"askeleen kohdalla otetaan kuvan väriarvo yksitellen jokaisen maskin pisteen kohdalta ja kerrotaan se maskin vastaavan pisteen arvolla ja nämä arvot summataan (eli lasketaan vastinosamatriisien sisätulo) sekä jaetaan maskin arvojen summalla ja laitetaan muunnetun kuvan uudeksi pisteeksi.

Esimerkiksi em. matriiseilla uuden kuvan paikassa (1,1) olevan pikselin kohdalta lasketuksi sisätuloksi (ks demo 7) tulisi:

 255*1 +   0*1 +   0*1 +
   0*1 + 255*1 +   0*1 +
   0*1 +   0*1 + 255*1    = 3*255 = 765

Tämä jaetaan vielä maskin arvojen summalla, eli 9, jolloin pisteen väriksi tulisi 765/9 = 85. Jos joudutaan käyttämään taulukon ulkopuolisia arvoja, niin arvona käytetään silloin 0:aa. Tässä tehtävässä jakajana käytetään aina 9. Myös muita tulkintoja on olemassa ja ne riippuvat tapauksesta.

Lisäinfoa katso Demo 9. B1-3. Konvoluutio.

Laske tuloskuvan jokaisen pikselin väriarvo.

Katkaise kukin jakolaskun tulos kokonaisluvuksi ja kirjoita tulos matriisimuotoon vastaavan luvun päälle niin, että lukujen paikka pysyy täsmälleen samana (oikealta tasattuina). Matriisiin kirjoitetaan nimenomaan lukuja, ei laskuja! TIM antaa pisteet vain jos on vastausalueessa yksi matriisi)

B2. Ääniä peliin

Muuta AngryLego-peliä niin, että putoava pää huutaa mennessään ja Symbian soittelee pudotessaan kännykän ääniä. Äänet saavat kuulua pitempäänkin, mutta tekemällä niistä noin 1-2 sekuntia pitkiä, ne eivät soi turhan kauaa. Pohjahakemistossa on valmiita ääniä jos et itse halua tehdä ääniä.

Saat tehdä tehtävän myös harjoitustyöllesi. Laita siinä tapauksessa muutosrivien lisäksi vielä linkki työsi svn-osoitteeseen.

B3. Koordinaatiston pikkuviivat

Muuta Kuvaaja.cs:ssä olevaa Axis-luokkaa niin, että se piirtää 4 pikkuviivaa (=jakaa viiteen osaan) jokaisen isomman välin sekä x-akselilla että y-akselilla.

B4. Moodi

M: 15. Taulukot, 16. Toistorakenteet. Tee funktioaliohjelma Moodi(luvut), joka etsii taulukon yleisimmän luvun. Jos eniten esiintyviä on yhtä monta, niin silloin ensimmäisenä näistä näistä löytynyt tulkitaan yleisimmäksi. Ennen ohjelmointia, mieti ensin kuinka itse ratkaisit tämän ongelman (eli mieti algoritmi). Et tarvitse aputaulukkoja välttämättä, vaan tehtävän voi ratkaista muutamalla apumuuttujalla. Moodi on yksi keskiluvuista. Toinen on keskiarvo. Kolmas keskiluvuista on mediaani, eli aineiston keskimmäinen alkio. Tätä ei vielä tarvitse tehdä. Mitä mediaanin laskemiseksi pitäisi ensin tehdä? Katso vaikka Wikipediasta keskiluku.

B5-7. Konvoluutio ohjelmalla

Tee C#-ohjelma, joka laskee mille tahansa harmaasävykuvalle ja maskille konvoluution. Ks. B1. Matriisien testaamisessa voit käyttää hyväksi Demo6:n mallivastauksen Matriisit-luokan Jonoksi-funktioita.

H1. Harjoitustyöhön joku viikon luentoihin liittyvä ominaisuus

Tehtävä H1 on vaihtoehto varsinaisille tehtäville, josta voi merkitä itselleen 1-2 p sen mukaan miten sen "vaikeus" suhteutuu muihin tehtäviin.

Lisää harjoitustyöhösi (se voi olla aluksi hyvinkin tyhjä "lumiukkopohja" jokin kurssiviikon aiheesseen liittyvä ominaisuus. Kommentoi koodiin selvästi missä "viikon" ominaisuutta on käytetty. Tällä viikolla esimerkiksi silmukat, taulukot ja 2-ulotteiset taulukot.

Jos harjoitustyöhön ei ominaisuutta saa lisättyä, voit tehdä myös pienen muun ohjelman, jossa harjoitelet ko. ominaisuuksia mikäli varsinaisista tehtävistä ei mieleistä vastaavaa harjoittelua löydy.

Mikäli teit toisenkin lisäyksen harjoitustyöhön, laita muutos seuraavaan laatikkoon.

G1-2. Hyppivät viholliset

Muuta AngryLego-peliä niin, että lego-vauvat hyppivät muutaman pikselin verran levottomina ylös/alas. Vinkki: tee vihollisista oma luokka ja tee sen Update-metodiin tarvittavat muutokset. Tarkista myös, että olion IsUpdated on true.

Saat tehdä tehtävän myös harjoitustyöllesi. Laita siinä tapauksessa muutosrivien lisäksi vielä linkki työsi svn-osoitteeseen.

PP 1

Korjaa annettu luokka syntaktisesti oikeaksi, niin että ohjelman pystyy taas ajamaan. Seuraa tehtävän ohjeita ja pyri tunnistamaan oikeat osat luokasta, pääohjelmasta ja aliohjelmista. Kirjoita myös dokumentit kaikkiin aliohjelmiin.

PP 2 a

Tee LaskeKaikkienMerkkienMaara-aliohjelma, joka laskee kaikkien string-taulukossa olevien jonojen pituudet yhteen ja palauttaa sen.

PP 2 b

Jatka edellistä aliohjelmaa siten, että sille annetaan myös etsitty merkki parametrinä.

• Ongelma kannattaa pilkkoa osiin!
  • Tee ensiksi aliohjelma LaskeMerkkienMaara(string jono, char etsitty).
  • Korvaa aiemmasta aliohjelmasta rivi, jossa kasvatat merkkien summaa, aliohjelmakutsulla LaskeMerkkienMaaraan.
  • Sinun ei pitäisi tarvita muuttaa aliohjelmaan kuin summaa kasvattavaa riviä ja annettuja parametrejä!

HUOM! Tehtävässä ei tarvitse laskea samaa merkkiä isona ja pienenä vaan pelkästään annetussa muodossa.

PP 3

Tee tehtävälistan alussa oleva Valintakoe-tehtävä (Tauno 2-3).

TÄRKEÄÄ: Kokeeseen ilmottautuminen

Korpissa on kurssin sivulla ilmoitettu kurssin tentit. Käy ilmottautumassa konetenttiin ja lukemassa tarkemmat ohjeet tentin järjestelyistä tentti-sivulta. Ja erityisesti ruksi kurssin Korppi-sivulla, mihin aikaan voit tulla 29.11 tenttiin.

Tauno ja Tehtävä 1 ovat tyypillisiä tenttitehtäviä, joten ne kannattaa vääntää vaikkeivat ole tähtitehtäviksi merkittykään.

Ville 1

Tällä kertaa ei tule uusia Ville-tehtäviä. Jos sinulla on tekemättä silmukka- ja/tai taulukkotehtäviä (tai muita joita et aikaisemmin ymmärtänyt), tee niitä 5 kappaletta. Tästä Villeen Muista: Villen käyttöohje ja Ville-tehtävien palauttamisohjeet.

Tauno (1p)

Tähän hyviä harjoittelutehtäviä ovat: Taulukot silmukalla, Etsiminen

Tee funktio, joka laskee kokonaislukutaulukosta suljetulla välillä 0-10 olevien lukujen keskiarvon. Jotta funktio olisi yleiskäyttöisempi, viedään sille parametrina myös tuo alaraja (esimerkissä 0) ja yläraja (esimerkissä 10). Mikäli keskiarvoa ei voi laskea, palautetaan arvo ala-1. Kirjoita myös testejä ainakin 5 kpl erilaisille taulukoille ja rajoille.

TDD1

Tehtävät, joissa on Test-painike, tulee testata Comtestillä, jotta saa täydet pisteet. Mikäli ComTest ei toimi yliopiston mikroluokissa, tarkista että ComTest haetaan oikeasta paikasta: Valitse Visual Studiossa Tools -> ComTest -> Options. Esiin tulee ComTest Plugin Options. Tarkista, että Path to ComTest.jar executable kentässä on N:\bin\ComTest.jar ja olet yhdistänyt koneesi N-verkkolevyyn.

Eli tällä kertaa testit eivät ole bonusta vaan tehtävään kuuluva osa. Piirtotehtäviä (portaat yms) on hankala testata ja sitä ei tehdä tällä kurssilla.

Pohjatiedostot varsinaisille tehtäville

• Tarvitaan tehtävissä 5,6-7,B1-3

  • tee Jypeli-projektit Kuva ja Palapeli
  • hae:
    • Kuva.cs,
    • Palapeli.cs,
  • korvaa edellä mainituilla projektiesi vastaavat tiedostot
  • lisää kummankin projektin Contenttiin:
    • numerot.png
    • vesa.png

Lue tarvittaessa (eli jos et ole vielä koskaan contenttia lisännyt) ohjeita kuvien ja äänien lisäämisestä: Sisällön tuominen peliin.

Xamarinissa saattaa tulla virheilmoitus rivinvaihdoista (line endings). Valitse tässä tilanteessa: Convert all files to UNIX line endings

Mikäli Kuva tai Palapeli-tyypistä tulee virheilmoitus, niin lisää Ohjelma.cs-kooditiedostoon

using Demo9;

Kokeile ajaa eri ohjelmia. Palapelissä hiiren klikkaus siirtää palaa ja Kuva-ohjelmassa tulee erilaisia kuvia.

Tehtävä 1. Taulukon nousevat

Jos yhtään vaikeuksia, katso: tehtävä jolla voi harjoitella.
Tähän muita hyviä harjoittelutehtäviä ovat: Taulukot silmukalla, Etsiminen

M: 15. Taulukot. Tee aliohjelma PisinNouseva, jolle annetaan parametrina kokonaislukutaulukko ja se palauttaa kokonaisluvun. Aliohjelma palauttaa pisimmän taulukosta löytyvän aidosti nousevan osajonon pituuden. Esimerkiksi jos taulukon alkiot ovat 2,3,4,1,2,0,1,2,5,5,7, niin palautetaan 4 (eli 0,1,2,5 muodostavat 4 lukua pitkän aidosti nousevan osajonon). Aloita tekemällä aliohjelman esittelyrivi ja tynkä. Testit kannattaa kirjoittaa ennen itse aliohjelman kirjoittamista (=TDD). Vinkkinä kannattaa katsoa Demo 8 Tauno-tehtävä sekä demonpalautusvideo sen käsittelystä.