Tämä sitten kun silmukat käsitelty: Onko vaikeuksia silmukoissa ja taulukoissa?

lue luentomonisteesta Silmukat-luku
aloita ensimmäistä Taunoista ja tee ne Taunolla ja sitten silmukalla. Tarvittaessa katso avuksi demonpalautusvideoita Tauno-tehtävän käsittelystä.
sitten siirry seuraaviin Taunoihin ja jatka kunnes kaikki käyty läpi!
tee kaikki taulukkotehtävät demojen harjoittelusivuilta
katso eri taulukkotehtävien vastauksia demojen mallivastauksista
katso luentovideoista taulukoista ja silmukoista
katso luento 11 esimerkkejä ja animaatioita
lue lisämateriaalista taulukoista ja silmukoista

Demojen harjoittelu 2024kesa

Tässä dokumentissa voit harjoitella demoja vastaavia tehtäviä. Näistä ei saa oikeasti demopisteitä, toki osaan tehtävistä tulee "leikisti" pisteitä.
Tehtävien perässä on tehtävään malliratkaisu, jonka voit avata sitten kun tuntuu siltä, että tarvitset apua, tai olet ratkaissut tehtävän.

Demo 3

3.4 Funktioita

Katso kertauksena: Funktion tekeminen Luento 6 – 19m20s (31m42s) 6. Aliohjelmat

Tämä on malli demo 3 tehtävään Funktioita. Tässä mallissa pitää tehdä funktio NelionAla.

Tehtävän aluksi kannattaa katsoa alta Näytä koko koodi. Ja sitten välillä pistää se pois, koska aliohjelmaa tehdessä ei saa enää ajatella, että mistä sitä kutsuttiin.

Jos olet ihan ulkona, katso ensin yllä oleva video.

Aloita miettimällä alla olevaan funktioon ISOLLA kirjoitettu sana kerrallaan, mitä pitää tulla siihen kohti ja kirjoita vastaava sana siihen. Jos et keksi, avaa vastaava vinkki. Katso vinkki sitten joka tapauksessa sanan täydentämisen jälkeen ja mieti oliko päättelysi oikein.

Kun valmis, muista Aja ja Test sekä katso myös Document ajatuksen kanssa.

Alla harjoittelutehtävän tekemistä ohjaava video kokonaisena. Mutta voi olla järkevää katsoa se alempaa pala kerrallaan, kun on ensin miettinyt itse mitä kunkin sanan kohdalle tulee ja sitten avaa vastaavan vinkin, lukee siinä olevan tekstin ja tarvittaessa katsoo vielä siinä olevan videon palan. Vinkit kannattaa sulkea lukemisen jälkeen niin sivun pituus ei kasva liikaa.

Harjoittelutehtävä kokonaisena videona Harjoittelu 03 (9m2s)

Aloitus: Tehtävän voi tehdä suoraan TIMIssä, mutta videossa se on tehty käyttäen Visual Studiota.

Tehtävän johdantoa ja aloittaminen Visual Studiossa (1m10s)

Nyt siirry tehtävään ja rupea sana kerrallaan miettimään mitä kirjoitetaan ja sitten katso vinkit.

# kuutio

Näkyvyysvinkki

NÄKYVYYS: Mieti onko funktio käyttökelpoinen muidenkin mahdollisesti käytettäväksi? Jos on, niin public. Esim jos funktiota aiotaan testata, pitää sen olla public.

Näkyvyysmääre – 1m10s (21s)

STATICvaiEI-vinkki

STATICvaiEI: voiko funktion tehtävän suorittaa pelkästään sillä datalla, joka tuodaan parametreissa. Tässä voi kannattaa avata Näytä koko koodi ja katsoa miten funktiota kutsutaan ja miettiä riittäisikö itselle tuo kutsussa oleva parametri asian laskemiseksi. Jos riittää, niin static.

static vai ei? – 1m31s (38s)

PALUUARVONTYYPPI -vinkki

PALUUARVONTYYPPI: Katso Näytä koko koodi. Minkä tyyppiselle muuttujalla funktion tulos sijoitetaan. Jos ei sijoiteta mihinkään, void, muuten sama tyyppi kuin on sillä muuttujalla johon tulos sijoitetaan. Olisiko se tällä kertaa ala-muuttujan tyyppi?

Paluuarvon tyyppi – 2m9s (48s)

FUNKTIONNIMI -vinkki

FUNKTIONNIMI: Avaa taas (jollei jo ole auki) Näytä koko koodi. Katso minkä nimistä funktiota pääohjelmassa kutsutaan. Tälle pitää antaa sama nimi.

Funktion nimi – 2m57s (13s)

PARAMETRINTYYPPI -vinkki

PARAMETRINTYYPPI: Katso minkä tyyppinen arvo on funktion kutsussa (eli nyt pääohjelmassa) suluissa funktion nimen perässä. Tähän sama tyyppi. Nyt kutsussa on muuttuja sivunpituus. Minkä tyyppiseksi se on esitelty?

Parametrin tyyppi – 3m10s (46s)

NIMI -vinkki

NIMI: parametrin nimeksi saa laittaa mitä tahansa. Kunhan lopussa koodissa käyttää samaa nimeä. Nimen kannattaa kuvata ihmisille tuttua asiaa. Esimerkkisi ympyrän tapauksessa hyviä nimiä olisivat sade tai r. Jossakin toisessa yhteydessä nimet ovat toki eri. Jos funktiolle on jo kirjoitettu dokumenttikommentit (kuten tässä esimerkissä, muista katsoa se koko koodi) ja niissä on kuvattu parametrin nimi, pitää toki käyttää sitä nimeä. Usein ensin kirjoitetaan funktion esittelyrivi ja siitä pyydetään dokumentin runko, eli silloin muuttujan nimen voi valita vapaasti.
Tässä tapauksessa dokumentaatiokommenteissa on käytetty nimeä s, joten sitä on käytettävä parametrin nimenä. Nimen ei tarvitse olla sama kuin kutsussa, mutta se saa olla.
Muista että muuttajien nimet alkavat pienellä kirjaimella!
Nimellä ei ole mitään tekemistä kutsussa olevan nimen kanssa, sillä aliohjelma (nyt funktio) muodostaa oman kokonaisuutensa ja se ei tiedä mitään pääohjelmasta. Aliohjelma saa tietyn määrän parametreja kutsuvalta aliohjelmalta (pääohjelmakin on vain aliohjelma) ja ottaa ne vastaan omiin parametreihinsa samassa järjestyksessä. Vertaa jos esimerkiksi työntäisit kaverille lappuja oven alta.

Parametrin nimi – 3m56s (54s)

LASKUTOIMITUS -vinkki

LASKUTOIMITUS: Oikeastaan tähän pitää kirjoittaa lauseke, joka tuottaa halutun tuloksen. Joku voi haluta laskea ensin tuloksen apumuuttujaan ja palauttaa tässä sitten apumuuttujan arvon. Yksi muuttuja on sinällään hyvä lauseke. Joku toinen voi haluta kirjoittaa tuloksen laskevan lausekkeen suoraan tähän. Lauseke riippuu tietysti valitusta parametrin nimestä sekä itse ongelmasta.
Videossa sanon vahingossa mock kun piti sanoa tynkä.

Funktion laskutoimituksen toteutus – 4m50s (4m12s)

Mallivastaus

    public static double NelionAla(double s)
    {
        return s * s;
    }

tai

    public static double NelionAla(double s)
    {
        double ala = s * s;
        return ala;
    }

tai

    public static double NelionAla(double s)
    {
        double ala:
        ala = s * s;
        return ala;
    }

Huomaa että tämä sama malli pätee kaikkiin aliohjelmiin joita kirjoitetaan. Voit aina aloittaa kopioimalla itsellesi tämän tehtävän lähtöpohjan (pääset siihen Alusta-linkillä) itsellesi.

# hyotyd3t4

Demo 4

4.2 Merkkijonofunktio

Esimerkki, jossa on samoja elementtejä kuin Tehtävässä 2. Tämä tehtävä on "vaikeampi" kuin itse demotehtävä.

Huom. Tehtävää tehdessä ei pidä miettiä sitä, mitä järkeä funktiossa on, tehtävä on laadittu vaan sellaiseksi, että funktiossa tulee käytettävksi eri tyyppisiä parametreja.

Tehtävänä on tehdä ohjelma, joka kysyy käyttäjältä merkkijonon ja sitten sen mukaan onko jono pidempi kuin 4 vai ei, tulostetaan Aika pitkä tai lyhyt.

Pohjassa on pääohjelma valmiina ja toteutettavaksi jää vain funktio OnkoPitka.

Pääohjelmassa olevat \" ovat sitä varten, koska jos halutaan tulostaa lainausmerkit, niin nehän katkaisisivat merkkijono. Joten siihen, mihin halutaan tulostuvan lainausmerkki, pitää laittaa lainausmerkin eteen takakeno \. Tällöin lainausmerkki tulkitaan tavalliseksi merkiksi, ei merkkijonon sulkevaksi lainausmerkiksi.

# onkopitka

Miten aloitan?

Katso Näytä koko koodi
Tutki miten aliohjelmaa/funktiota kutsutaan pääohjelmasta, entä testeistä. Jos aliohjelman palauttama tulos sijoitetaan johonkin, on kyseessä funktio (eli ei void).
Montako parametria on kutsuissa? Vastaus 3
Ensimmäinen tavoite on kirjoittaa funktion esittelyrivi ja tynkätoteutus.

Miten esittelyrivi alkaa?

koska funktiota voisi käyttää muutkin, tehdään siitä julkinen. Esim testejä ei voitaisi ajaa jos funktio ei olisi julkinen, koska itse testit menevät eri tiedostoon ComTest-ajon tuottamassa toteutuksessa (ks VisualStudiossa Test-loppuisia projekteja ja niissä Test.cs loppuisia tiedostoja.
koska pelkissä parametreissä on riittävästi tietoa tehtävän suorittamiseen, tehdään funktiosta staattinen, eli alkuun:
```
  public static
```

Mikä on funktion paluuarvo?

pääohjelmassa funktion palauttama arvo on sijoitettu muuttujalle tulos, joka näyttää oleva string-tyyppinen.
siis funktion paluuarvonkin pitää olla string, eli kirjoitetaan
```
  public static string
```

Mitä paluuarvon jälkeen?

paluuarvon kirjoittamisen jälkeen kirjoitetaan funktion nimi. Funktion nimi on yleensä kiinnitetty, kun mietitään miten funktiota kutsutaan. Niin nytkin. Pääohjelmasta ja testeistä selviää että nimi on OnkoPitka. Kirjoitetaan se ja saman tien pakolliset sulut ja ei missään nimessä puolipistettä funktion esittelyriville. Eli toistaiseksi meillä on:
```
  public static string OnkoPitka()
  {
  }
```

Mikä on ensimmäinen parametri?

nyt pitäisi saada kaarisulkuihin oikea määrä oikeantyyppisiä ja -nimisiä parametreja
pääohjelmassa ja jokaisessa testissä näyttää kutsuissa olevan 3 parametria, joten kaarisulkuihin pitää saada vastaava määrä.
kutsun ensimmäinen parametri näyttää olevan merkkijono ja dokumenteissa sen nimenä on jono, eli lisätään se ensin:
```
  public static string OnkoPitka(string jono)
  {
  }
```

Toinen parametri?

kutsuissa toisena parametrina näyttää olevan aina jokin kokonaislukuarvo. Siis toisen paranetrin tyyppi on int. Nimi selviääkin dokumentaatiosta, joten listään 2. parametri:
```
  public static string OnkoPitka(string jono, int rajapituus)
  {
  }
```

Kolmas parametri?

kutsuissa on myös kolmas parametri joka on esim pääohjelmassa olevassa kutsussa: "Aika pitkä". Kaksinkertaiset lainausmerkit? Eli tämähän on "merkkijonovakio" ja silloin parametrin pitää olla sellainen, johon tämä voidaan sijoittaa, eli string. Taas muuttujan nimi selviää dokumentaatiokommenteista (koska ne olivat nyt valmiina, jos eivät olisi olleet, niin nimi keksittäisiin itse ja kerrottaisiin se dokumentaatiokommenteissa). Kutsuissa oli kolme parametria ja meillä on nyt esittelyrivillä kolme parametria, joten on esittelyrivi valmis:
```
  public static string OnkoPitka(string jono, int rajapituus, string pitkaJono)
  {
  }
```

Tynkätoteutuksen tekeminen

seuraava vaihe on saada funktiosta tynkä, eli sellainen, mikä on mahdollisimman lyhyt syntaktisesti oikein oleva toteutus, joka ei kuitenkaan missään nimessä saa mennä testeistä läpi. Yksi hyvä tynkä olisi palauttaa tyhjä merkkijono, eli:
```
  return "";
```
kuitenkin tehtävän määrityksen mukaan joudumme useassa tapauksessa (eli jonon ollessa lyhyt) palauttamaan vakiojonon "lyhyt", joten voimme laittaa tämän suoraan jo tynkään. Eli silloin koko toteutus olisi toistaiseksi:
```
      public static string OnkoPitka(string jono, int rajapituus, string pitkaJono)
      {
          return "lyhyt";
      }
```

Punaisen näkeminen

Oikeasti seuraava vaihe olisi kirjoittaa funktion dokumentaatiokommentit ja sitten riittävän kattavat testit, mutta koska meillä ne on jo tässä esimerkissä valmiina, siirrymme seuraavaan vaiheeseen.
Ja se seuraava vaihe on ajaa testit ja nähdä punaista. Koko ohjelman on luonnollisesti oltava syntaksiltaan oikein, jotta testit voidaan kääntää ja ajaa. Ja sitä se onkin koska esittelyrivi on oikein ja toteutuksena tynkä.
Eli aja testit ja näe punaista niistä!

Algoritmi

Sitten seuraa ohjelmoinnin vaikein vaihe: Pitää kyetä sanomaan omalla äidinkielellä yksikäsitteisesti se mitä ollaan tekemässä. Tämä usein unohtuu ja jos sitä ei osaa sanoa omalla kielellä, ei sitä pysty sanomaan vieraallakaan kielellä.

Eli nyt tuo olisi jotakin tyyliin:

Jos jonon pituus on suurempi kuin rajapituus niin palauta pitkaJono.
muuten palauta teksti "lyhyt".

Toteutuksen aloittaminen

Nyt kun tiedetään mitä ollaan tekemässä, voidaan aloittaa toteutuksen tekemistä "kääntämällä" algortimia pala kerrallaan kohdekielelle, eli tällä kurssilla C#-kielelle.
Ensin pitäisi saada selville jonon pituus. Etsitään luentomonisteesta merkkijonojen kohdalta tai Microsoftin merkkijonodokumentaatiosta vastausta kysymykseen. MS:n dokumentaatiosta tätä voi olla haastavaa löytää, mutta Googlen hakusanalla msdn string length voi löytyä oikea kohta. Luentomonisteesta vastaus löytyy helpommin :-)
eli selviää että merkkijonolla on ominaisuus (ei funktio/metodi) Length joka antaa jonon pituuden kokonaislukuna. Sijoitetaan pituus talteen kokonaislukutyyppiseen apumuuttujaan. Lisätään siis oman funktiomme ensimmäiseksi riviksi:
```
  int jononPituus = jono.Length;
```
Loppuun ei tule sulkuja, koska kyseessä ei ole metodikutsu.
Huomaa että pääohjelmassa esiintynyttä vakiota 4 ei missään tapauksessa saa esiintyä funktiossa! Testeissä se voi toki olla tarvittaessa.

Pituuden vertailu

Nyt kun jonon pituus on tiedossa, voidaankin verrata sitä rajapituuteen:
```
  if ( jononPituus > rajapituus )  
```
ja jos ehto toteutui, piti tehtävän määrityksen mukaan palauttaa kolmantena parametrina tuotu merkkijono, eli koko seuraava rivi olisi silloin:
```
  if ( jononPituus > rajapituus ) return pitkaJono;
```
jotkut tykkäävät kirjoittaa toteutuksen eri riville muodossa:
```
  if ( jononPituus > rajapituus ) 
      return pitkaJono;
```
tässä on se riski, että jos halutaan useampia lauseita ehdon ollessa voimassa ja lauseita lisätään luullen sisennysten vaikuttavan suoritukseen. Sen takia monet pitävät varmempana käyttää aina lohkosulkuja jos suoritettavaa lausetta ei kirjoiteta samalle riville ehdon kanssa:
```
  if ( jononPituus > rajapituus ) 
  {
      return pitkaJono;
  }
```
huomaa että on myös muita vertailuoperaattoreita ja tilanteen mukaan niistä pitää valita oikea. Ensin mietitään huolella tarvitaanko erisuuruutta jonkin suuntaan, yhtäsuuruutta samalla vai pelkästään. Tässä tapauksessahan vaadittiin nimenomaan puhdasta suuremmuutta.

Entä jos ehto ei toteudu?

Jos ehto ei toteudu, eli jonon pituus onkin rajan kanssa yhtäsuuri tai pienempi, niin silloin suoritusta jatketaan seuraavalta riviltä ja tynkätoteutuksemme ansiosta siinä tapauksessa palautetaan teksti "lyhyt" kuten pitikin. Eli mitään lisäehtoa tai else-osaa ei tässä tarvita.
vaikuttaisikin että olemme valmiita ja voimme ajaa testit ja meidän pitäisi nyt nähdä vihreää.

Pääohjelman ajaminen

Koska oikeasti aliohjelma/funktio tehdään tarpeeseen ja meillä se tarve oli tuolla pääohjelmassa, niin ehkä pääohjelmakin on syytä ajaa. TIMissä ajamista varten Aja-painikkeen yläpuolelle kirjoitetaan pääohjelman tarvitsema syöte. Kirjoitetaan vaikka ensin siihen
```
  kissa
```
ja ajetaan ohjelma. Pitäisi tulostua haluttu viesti.
kokeillaan seuraavaksi kirjoittaa:
```
  koi
```
ja ajetaan taas. Nyt pitäisi tulostua lyhyt.
Taidamme olla valmiita?
Ei, katsotaan vielä huolella Document-linkistä minkälainen dokumentaatio syntyy kommenttiemme ansiosta (jotka nyt oli valmiina, mutta usein pitää kirjoittaa itse). Klikkaa dokumentaatiossa sanaa class PidempiSana ja katso miten itse funktion kuvaus näkyy. Sitten rullaa alaspäin ja katso miten parametrit näkyvät ja vielä alempana miten testit näkyvät "esimerkkeinä".

Mallivastaus

    public static string OnkoPitka(string jono, int rajapituus, string pitkaJono)
    {
        int jononPituus = jono.Length;
        if ( jononPituus > rajapituus ) return pitkaJono;
        return "lyhyt";
    }

Muita malliratkaisuja

Apumuuttuja pois:

public static string OnkoPitka(string jono, int rajapituus, string pitkaJono)
{
    if ( jono.Length > rajapituus ) return pitkaJono;
    return "lyhyt";
}

tai "funktionaalinen" ratkaisu (ei tarvitse osata):

public static string OnkoPitka(string jono, int rajapituus, string pitkaJono)
{
    return jono.Length > rajapituus ? pitkaJono: "lyhyt";
}

# hyotyd4t2

# charluokka

4.4 Char-luokka

Olkoon ongelmana selvittää onko merkkijonon viimeinen kirjain numero vaiko ei. Mikäli kyseessä on numero, palautetaan totuusarvo true ja muuten totuusarvo false. Huomattakoon että vastaavassa demotehtävässä kysymyksen asettelu on hieman toinen.

Aloitetaan sopivalla testipääohjelmalla ja sen perusteella luodulla funktiolla, sen kommenteilla ja testeillä. Avaa taas aluksi Näytä koko koodi.

# loppuunumeroon

Totuusarvon testaamisesta

Huomaa pääohjelmassa miten totuusarvoista funktiota voidaan käyttää puhekielimäisesti

        if (!LoppuuNumeroon(jono1)) ...

jos ei lopu numeroon

        if (LoppuuNumeroon(jono2)) ...

jos loppuu numeroon

Eli totuusarvoja EI ole tapana testata tyyliin

        if (LoppuuNumeroon(jono1) == false) ...
        if (LoppuuNumeroon(jono2) == true) ...

koska ei puhekielessäkään sanota (filosofeja lukuunottamatta :-), että

jos loppuun numeroon on epätosi ...
jos loppuu numeroon on tosi ...

Funktion tyngäksi riittää palauttaa jompikumpi totuusarvoista, esimerkiksi

        return false;

Sitten teisteissä on hyvä kokeilla eir mittaisi jonoja. Aina pitää muistaa, että myös tyhjä jono on laillinen merkkijono. Silloin ei ole viimeistä merkkiä ja silloin se ei ainakaan voi olla numero, eli siitä palautetaa false. Myös yhden merkin jono on syytä pitää testeissä mielessä.

Viimeinen merkki

Koska meidän pitää selvittää viimeinen kirjain, pitää saada selville sen paikka.

012345
kissa

Tässä esimerkkijonossa on 5 kirjainta ja viimeisen indeksi on 4. Eli jonon pituudesta saadaan selville viimeisen merkin paikka ja itse merkki ihan kuten saadaan taulukon yksi alkio, eli tyyliin:

        int pituus = jono.Length;
        char viimeinen = jono[pituus - 1];

Tässä on kuitenkin se riski, että jos jono on tyhjä, on sen pituus 0 ja ohjelma kaatuu kun yritetään ottaa merkki paikasta 0-1 == -1.

Siksi on tässä tapauksessa turvallisinta käsitellä ensin tyhjä jono erikoistapauksena:

        int pituus = jono.Length;
        if (pituus == 0) return false;
        char viimeinen = jono[pituus - 1];

Tutkitaan onko numero ja palautetaan tulos

Seuraavaksi pitäisi tietää onko kyseessä numero. Tämä voitaisiin testata ASCII-koodin järjestykseen luottaen tyyliin

        if ('0' <= viimeinen && viimeinen <= '9') return true;

Tehtävässä on kuitenkin tarkoitus harjoitella Char-luokan funktioiden käyttöä ja siksi pitää etsiä sivulta:

Char-luokan dokumentaatio

tähän sopiva valmis funktio (M$ käyttää nimeä metodi noista vaikka kyseessä on staattinen funktio, eli kutsumiseen ei tarvita mitään oliota, se yksi kirjain riittää). Huolellisen lukemisen jälkeen löytyy

IsDigit(Char) Indicates whether the specified Unicode character is categorized as a decimal digit.

Klikattaessa tuota funktion nimeä, päädytään sivulle, jossa lukee funktion esittelyrivin muoto

    public static bool IsDigit (char c);

Toinen tärkeä havainto sivulta on että kyseessä on luokka Char ja se on nimiavaruudessa System. Näiden perusteella funktiota kutsutaan tyyliin

        bool onkoNumero = System.Char.IsDigit(viimeinen);

jos koodissa on jo using System;, ei sitä tarviste toistaa, eli kutsu olisi

        bool onkoNumero = Char.IsDigit(viimeinen);

Toisaalta sitten tulisi koodia:

        bool onkoNumero = Char.IsDigit(viimeinen);
        if (onkoNumero) return true;
``

ja samalla vaivalla tuon voi tehdä ilman apumuuttujaa, eli    

```C#

        if (Char.IsDigit(viimeinen)) return true;

Ja sitten jos numeron tapauksessa on lähdetty pois funktiosta, niin kaikissa jäljelle jääneissä tapauksissahan kyseessä ei ole numero, eli silloin pitäisi palauttaa false:


        return false;

Microsoftin omassakin dokumentaatiossa on horjuvuutta sen suhteen kirjoitetaanko char vai Char. Rider haluaa kirjoittaa sen pienellä. ```

Mallivastaus 1

    public static bool LoppuuNumeroon(string jono)
    {
        int pituus = jono.Length;
        if (pituus == 0) return false;
        char viimeinen = jono[pituus - 1];
        if (char.IsDigit(viimeinen)) return true;
        return false;
    }

Mallivastaus 2

Useinkaan totuusarvojen palautuksissa ei ole tapana käyttää rakennetta

        if (ehto) return true;
        return false;

koska ehto on jo itsessään true tai false. Siksi riittää sanoa suoraan

        return ehto;

Eihän numeerisessakaan tilanteessa tehtäisi koodia

        if (n == 1) return 1;
        if (n == 2) return 2;
        if (n == 3) return 3;
        ...

vaan ilman muuta kirjoitettaisiin vain:

        return n;

Eli siksi tämänkin vastaus olisi ehkä mieluummin:

    public static bool LoppuuNumeroon(string jono)
    {
        int pituus = jono.Length;
        if (pituus == 0) return false;
        char viimeinen = jono[pituus - 1];
        return char.IsDigit(viimeinen);
    }

ja joku voisi vielä lyhentää:

    public static bool LoppuuNumeroon(string jono)
    {
        if (jono.Length == 0) return false;
        return char.IsDigit(jono[pituus - 1]);
    }

Tosi nörtti tekisi vielä lyhyemmän:

    public static bool LoppuuNumeroon(string jono)
    {
        return (jono.Length > 0 && char.IsDigit(jono[^1]));
    }

Tuossa ratkaisussa käytetään hyväksi sitä, että useimmissa kielissä ja (&&)-operaatio (huom kaksi &-merkkiä) katkaisee suorituksen, jos jo ensimmäinen osa on epätosi ja tuottaa lausekkeen arvoksi false ja silloin ei edes mennä katsomaan -1 paikassa olevaa merkkiä. Uudemmassa .Net on käytössä taulukoiden indeksin operaattori ^, jonka perässä oleva luku ilmaiseen montako alkiota mennään pituudesta taaksepäin.

Käyttäen C#:in funktionaalista muotoa ja lyhentämällä jonon nimi pelkäksi s saadaan vielä muutama vaihtoehto:

    public static bool LoppuuNumeroon(string s) => s.Length > 0 && char.IsDigit(s[^1]);

```C#

    public static bool LoppuuNumeroon(string s) => s.Length > 0 && '0' <= s[^1] && s[^1] <= '9';

Käyttäen säännällistä lauseketta jossa ehtona onn umeroon loppuminen:

```C#
    public static bool LoppuuNumeroon(string s) => Regex.IsMatch(s, @".*[0-9]$");

# hyotyd4t4

# d5

Demo 5

Aloita aina tehtävä avaamalla Näytä koko koodi ja sitten tutustu huolella pääohjelmaan.

# d5t1

5.1 StringBuilder

# lisaakeskelle

Harjoittelutehtävä kokonaisena videona Harjoittelu 05_1 (9m12s)

Algoritmi

Kirjoita ruutupaperille merkkijonoja ja sitten lisää niiden keskelle joku teksti. Eli harjoittele ensin ongelman kanssa.

Mieti ensin useilla eri jonoilla mitä pitäisi tehdä. Eli piirrä jonoja ja niiden päälle indeksit:

Esim kana ja pitäisi lisätä mala:

0123                                     01234567
kana   lisäys tulee paikan 2 eteen, eli  kamalana

Esim kissa ja lisätään va:

01234                                   0123456
kissa  lisäys taas paikan 2 eteen, eli  kivassa

Mieti mitä tarkoittaa puoliväli? Jos on parillinen määrä, kuten abba-sanassa, niin lisäyksen paikka on jonon pituuden puolikas, eli 4/2 = 2. Jos pituus on pariton, niin joudutaan valitsemana jompikumpi paikka, sillä paikkaa 2.5 ei ole. Valitaan alempi, eli katkaistaan jakolaskun tulos. Mieti toimiiko valittu idea myös vaikka 8 ja 9 mittaisille jonoille?

Vinkit

Klikkaa Näytä koko koodi.
Kirjoita aikaisempien oppien perusteella aliohjelman esittelyrivi ja tee tynkä. Lue tyypit huolella.
- toki alkuun public static
- tulosta ei sijoiteta pääohjelmassa mihinkään => void
- aliohjelman nimi on LisaaKeskelle
- kutsussa kaksi parametria
  - 1. tyyppi on StringBuilder ja dokumentaatiossa sille on annettu nimi jono
  - 1. on pääohjelmassa "kivi" eli tuon voi sijoittaa merkkijonolle, joten tyyppi on string ja dokumentaatiossa nimenä on lisateksti.
=>
```
     public static void LisaaKeskelle(StringBuilder jono, string lisateksti)
     {
     }
```
Etsi muuttuvan merkkijonon avustuksista millä metodilla voi lisätä muuttuvan merkkijonon keskelle merkkijonon:
- luentomoniste
- MS-dokumentti
Mieti, miten saat selville jono-muuttujan puolivälin indeksin. Tallenna tämä puolivälin sijainti uuteen muuttujaan int puolivali.
jono.Insert(puolivali, lisateksti);

Mallivastaus

    public static void LisaaKeskelle(StringBuilder jono, string lisateksti)
    {
        int puolivali = jono.Length/2;
        jono.Insert(puolivali, lisateksti);
    }

Parannus testeihin: muutetaan sivuvaikutukselliseksi funktioksi

Testien tekeminen void-aliohjelmille on hieman työlästä.
Tässä esimerkissä jokaista testiä varten tarvittiin 3 riviä. Tätä voi helpottaa tekemällä niin, että aliohjelma palauttaa lopuksi viitteen muuttamaansa jono-olioon. Tällöin aliohjelmasta ei tule puhdas funktio, koska sillä on sivuvaikutus; se muuttaa itse jono-oliota. Tällöin sanotaan, että funktio on sivuvaikutuksellinen.
Yleensä aliohjelman (void) muuttaminen sivuvaikutukselliseksi funktioksi ei riko jo tehtyä koodia, koska funktion palauttamaa arvoa ei ole pakko C#-kielessä ottaa kiinni.

Muutetaan LisaaKeskelle sivuvaikutukselliseksi funktioksi ja tehdään testit ketjuttamalla LisaaKeskelle- ja ToString-aliohjelmien kutsut:

     /// <pre name="test">
     /// LisaaKeskelle(new StringBuilder("Abba"), "c").ToString() === "Abcba";
     /// LisaaKeskelle(new StringBuilder(""), "a").ToString() === "a";
     /// LisaaKeskelle(new StringBuilder("123"), "4").ToString() === "1423";
     /// </pre>
     /// </example>
     public static StringBuilder LisaaKeskelle(StringBuilder jono, string lisateksti)
     {
         int puolivali = jono.Length/2;
         jono.Insert(puolivali, lisateksti);
         return jono;
     }

# hyotyd5t1

# d5t2

5.2 Taulukot ilman silmukkaa

# montako3

Harjoittelutehtävä kokonaisena videona Harjoittelu 05 2 (3m43s)

Algoritmi

Sinun pitää laskea taulukossa niiden lukujen määrä, jotka halutaan laskea.
Mieti ensin algoritmi miten itse tekisit:
- sinulle annetaan ruutupaperilla rivi lukuja (=taulukko)
- alusta lkm-laskuri nollaksi
- käy taulukon jokaisessa alkiossa
  - jos alkio on tutkittava luku, niin
    - lisää lkm laskuria yhdellä
- kun kaikki kuvut käyty läpi, tulos on laskurissa lkm

Vinkit

Siten sama ohjelmaksi. Avaa ensin koko ohjelman näkyviin jotta näet kutsun muodon.
Kirjoita funktion esittelyrivi
- luonnollisesti public static
- aliohjelman tulos on sijoitettu pääohjelmanssa maara-muuttujaan joka on tyypiltään int, eli funktion tyypiksi int.
- pääohjelmassa on kutsussa kaksi parametria
- ensimmäinen on luvut joko on näköjään tyypiltään int[] eli ensimmäisen parametrin tyyppi on int[] ja dokumentissa sen nimi on luvut
- toinen kutsuparametri on 6 eli se voidaan sijoittaa int-tyyppiselle muuttujalle ja parametrin nimeksi on annnettu dokumentissa luku
- näin ollen esittelyrivi on:
```
     public static int Montako(int[] luvut, int luku)
```
Tee tynkä ja kokeile että toimii ja antaa testeistä punaista
- koska funktio palauttaa kokonaisluvun, niin tynkätoteus voisi olla:
```
    public static int Montako(int[] luvut, int luku)
    {
        return 0;
    }
```
Lisää apumuuttuja lukumäärän laskemiseksi ja alusta se nollaksi
```
 lkm = 0;
```
Tee tässä tehtävässä "tyhmästi", eli tutki jokaisen alkion kohdalta erikseen onko se haluttu, esim indeksin 1 kohdalla olevasta kirjoita:
```
 if ( luvut[1] == luku ) lkm++;
```

Mallivastaus

        public static int Montako(int[] luvut, int luku)
        {
            int lkm = 0;
            if ( luvut[0] == luku ) lkm++;
            if ( luvut[1] == luku ) lkm++;
            if ( luvut[2] == luku ) lkm++;
            return lkm;
        }

# hyotyd5t2

# d5t3a

5.3 Lukujen tulostaminen

Tulostuksen on oltava täsmälleen alla olevan kaltainen:

Luku Toiseen
 0     0
 1     1
 2     4
 3     9
 4    16
 5    25
12345678

eli luku-muuttujalle varataan tilaa 2 paikkaa ja sitten kolme välilyöntiä ja toisen potenssin kohdalla varataan tilaa 3 paikkaa. Alin rivi on vain luettelo sarakkeista, mihin mikäkin pitää tulostaa, sitä ei tulosteta oikeasti.

# tulostatoiseen

Harjoittelutehtävä kokonaisena videona Harjoittelu 05 3 (15m33s)

Tynkä

Kopioi tehtävän pohja Visual Studioon uudeksi projektiksi:

Näytä koko koodi
paina Copy-linkkiä (pohja menee leikepöydälle)
luo uusi ConsoleMain-projekti nimelle TulostaPotensseja
Avaa syntynyt TulostaPotensseja.cs
valitse kaikki Ctrl-A
liitä pohja maalatun tilalle Ctrl-V

Sitten tehdään tynkä:

kirjoita aliohjelman esittelyrivi

tee tynkä:

 public static void TulostaToiseen(int alku, int loppu)
 {
 }

kokeile että kääntyy ja tulostaa sen mitä pääohjelmassa on tulostettu
Fiksu vielä tässä vaiheessa dokumentoi aliohjelman eli laittaa edellisellä rivillä /// ja sitten täydentää syntyneen tekstin. Tällaista tulostavaa aliohjelmaa ei ole helppoa testata, joten tällä kertaa jätämme testit kirjoittamatta.

Silmukaton "tyhmä" versio aluksi

Aloita miettimällä miten tulostaisit luvut ilman mitään silmukoita tai muita kotkotuksia:

 Console.WriteLine(" 0     0");
 Console.WriteLine(" 1     1");
 Console.WriteLine(" 2     4");
 Console.WriteLine(" 3     9");
 Console.WriteLine(" 4    16");
 Console.WriteLine(" 5    25");

Tämä ei tietenkään kelpaa vastaukseksi, sillä tässä rivien määrä olisi aina sama, mutta tästä on hyvä lähteä liikkeelle. Kokeile!

Silmukaton versio muuttujilla

Vaihdetaan seuraavaksi kiinteiden vakionumeroiden paikalle muuttujia:

 int tulo;
 int luku = 0;

 tulo = luku * luku;
 Console.WriteLine("{luku} {tulo}");
 Console.WriteLine("{luku} {tulo}");
 Console.WriteLine("{luku} {tulo}");

// jne

Kokeile!

Tämä ei tietenkään toimi, koska joka kerta käytetään samoja muuttujien arvoja. Siksi seuraavaa lausetta varten muutetaan muuttujien arvoja niin, että seuraavakin lause toimii (alla olevia kommentteja ei tarvitse kirjoittaa, niillä vaan näytetään samoja asioita joita näkisi debgerilla)

 int tulo;
 int luku = 0;

 tulo = luku * luku;                  // 0*0 = 0
 Console.WriteLine("{luku} {tulo}");  // tuostuu 0 0  
 luku++;                              // luku muuttuu 1:ksi 

 tulo = luku * luku;                  // 1*1 = 1
 Console.WriteLine("{luku} {tulo}");  // tulostuu 1 1
 luku++;                              // luku muuttuu 2:ksi  

 tulo = luku * luku;                  // 2*2 = 4
 Console.WriteLine("{luku} {tulo}");  // tulostuu 2 4
 luku++;                              // luku muuttuu 3:ksi

// jne

Tulostuksen muotoilu

Tuloksen muotoilu ei mene aivan kuten tehtävässä haluttiin!
Lue luentomonisteesta lukujen muotoilusta. Tulosta luku ja sen toinen potenssi oikein muotoiltuna
```
 Console.WriteLine($"{luku,2}   {tulo,3}");
```
Vaihda em. rivi kaikkien tulostusrivien kohdalle ja kokeile näyttääkö nyt hyvälle.

Muutetaan silmukaksi

Nyt meillä toistuu monta kertaa identtinen kolmen lauseen lohko:

tulo = luku * luku;
Console.WriteLine($"{luku,2}   {tulo,3}");
luku++;

Tehdään tästä oikea lohko lisäämällä lohkosulut (eli aaltosulut):

{
    tulo = luku * luku;
    Console.WriteLine($"{luku,2}   {tulo,3}");
    luku++; 
}

Tehdään tästä while -silmukka joka jatkaa niin kauan kuin luku on pienempi tai yhtäsuuri kuin loppu. Älä vaan laita puolipistettä while-rivin loppuun, sillä se tekisi ikuisen silmukan jonka suoritettava lause on se, mitä mahtuu ) ja ; väliin.
```
while (luku <= loppu)
{
    tulo = luku * luku;
    Console.WriteLine($"{luku,2}   {tulo,3}");
    luku++; 
}
```
Poista ylimääräiset samanlaiset lohkot.
Kokeile toimiiko oikein.
Laita Visual Studiossa keskeytyskohta riville int tulo;
Aja debuggerilla keskeytyskohtaan
Askella silmukkaa niin, että aina ennen seuraava askelta yrität miettiä mitä tulee mihinkin muuttujaan ja mitä tulee tapahtumaan kun rivi suoritetaan. Kun joka kerta "arvaat" oikein, voit lopettaa askeltamisen.
Tee em. debuggausharjoitus JOKAISELLE muullekin tämän harjoitussivun tehtävistä.

Vaihtoehtoja muotoiluun ja apumuuttujiin

Tässä pärjättäisiin ilmankin apumuuttujaa tulo, sillä lasku voitaisiin laskea tulostuslauseessa suoraan:
```
Console.WriteLine($"{luku,2}   {luku*luku,3}");
```
tai:
```
Console.WriteLine("{0,2}   {1,3}", luku, luku*luku);
```

Muotoilun vaatimuksen kolmesta välilyönnistä lukujen välillä voi hoitaa myös jommalla kummalla seuraavista:

 Console.WriteLine($"{luku,2}{' ',3}{luku*luku,3}");
 Console.WriteLine("{0,2}{1,3}{2,3}", luku, " ", luku*luku);

Kokeile myös mitä tapahtuu jos WriteLine sijaan kirjoitat Write.

Mallivastaus - while

    public static void TulostaToiseen(int alku, int loppu)
    {
        int luku = alku;
        while ( luku <= loppu )
        {
            Console.WriteLine($"{luku,2}   {luku*luku,3}");
            luku++;
        }
    }

Mallivastaus - for. Miten while muutetaan for-silmukaksi?

C#-kielen for-silmukka on (melkein) vain erilainen tapa sanoa while-silmukka. Siinä while-silmukan kolme osaa:

alustuslause (nyt se oli int alku = 0;)
ehto (nyt se oli luku <= loppu)
kasvatuslause (nyt se oli luku++)

on kirjoitettu yhteen paikkaan, jotta silmukan toimintaa on helpompi kontrolloida.

Aloita while-silmukkavastauksesta. Silmukan muuttaminen for-silmukaksi:

Kirjoita muuttujan alustuksen eteen for välilyönti ja kaarisulku:

     for (int luku = alku;
     while ( luku <= loppu )
     {
         Console.WriteLine($"{luku,2}   {luku*luku,3}");
         luku++;
     }

Pyyhi while ( ja sen edellä oleva rivinvaihto pois niin, että ehto nousee samalla riville for kanssa:

     for (int luku = alku; luku <= loppu )
     {
         Console.WriteLine($"{luku,2}   {luku*luku,3}");
         luku++;
     }

Siirrä kasvatuslause luku++ for:in ehdon perään puolipisteellä erotettuna:

     for (int luku = alku; luku <= loppu; luku++)
     {
         Console.WriteLine($"{luku,2}   {luku*luku,3}");
     }

Koska suoritettavana on nyt vain yksi lause, voisi silmukan kirjottaa myös ilman lohkosulkuja:

     for (int luku = alku; luku <= loppu; luku++)
         Console.WriteLine($"{luku,2}   {luku*luku,3}");

Lopullinen vastaus for-silmukkana:

 public static void TulostaToiseen(int alku, int loppu)
 {
     for (int luku = alku; luku <= loppu; luku++)
     {
         Console.WriteLine("{0,2}{1,3}{2,3}", luku, " ", luku*luku);
     }
 }

Mallivastaus - do-while. Miten while muutetaan do-while -lauseeksi?

do-while -silmukan ero on, että silmukka tehdään aina yhden kerran. while ja for-silmukoissa voi käydä niin, ettei silmukkaa tehdä yhtään kertaa.
Aloitetaan taas while-vastauksesta.

Jos while-silmukka on:

 int luku = alku;
 while ( luku <= loppu )
 {
     ... jotakin ...
     luku++;
 }

niin leikkaa pois while ja ehto ja korvaa ne do-sanalla:

 int luku = alku;
 do
 {
     ... jotakin ...
     luku++;
 }

liimaa leikkaamasi while ja ehto silmukan loppusulun perään välilyönnillä erotettuna ja lisää sinne vielä puolipiste. Huomaa että do-while rakenteen pitää päättyä puolipisteeseen. while-silmukka ei ole vielä valmis sillä while-rivillä, joten silloin puolipistettä ei saa laittaa.
```
 int luku = alku;
 do
 {
     ... jotakin ...
     luku++;
 } while ( luku <= loppu );
```

Lopullinen vastaus:

 public static void TulostaToiseen(int alku, int loppu)
 {
     int luku = alku;
     do 
     {
         // Console.WriteLine($"{luku,2}   {luku*luku,3}");
         // Console.WriteLine($"{luku,2}{' ',3}{luku*luku,3}");
         // Console.WriteLine("{0,2}   {1,3}", luku, luku*luku);
         Console.WriteLine("{0,2}{1,3}{2,3}", luku, " ", luku*luku);
         luku++;
     } while ( luku <= loppu );
 }

# hyotyd5t3

# d5t4b

5.4 Taulukot silmukalla

# montakoN

Harjoittelutehtävä kokonaisena videona Harjoittelu 05 4 (11m20s)

Vinkkejä

kirjoita funktion esittelyrivi

ota mallivastaus 3:n alkion tehtävästä:

 int lkm = 0;
 if ( luvut[0] == luku ) lkm++;
 if ( luvut[1] == luku ) lkm++;
 if ( luvut[2] == luku ) lkm++;
 return lkm;

muuta vakioindeksien tilalle muuttuja

 int lkm = 0;
 int i = 0;
 if ( luvut[i] == luku ) lkm++;
 if ( luvut[i] == luku ) lkm++;
 if ( luvut[i] == luku ) lkm++;
 return lkm;

Nyt vain 1. rivi toimii, eli indeksiä on kasvatettava lauseiden välillä:

 int lkm = 0;
 int i = 0;
 if ( luvut[i] == luku ) lkm++;
 i++;
 if ( luvut[i] == luku ) lkm++;
 i++;
 if ( luvut[i] == luku ) lkm++;
 i++;
 return lkm;

Nyt löytyy nätti lohko jossa kaikki lauseet ovat samanlaisia:
```
if ( luvut[i] == luku ) lkm++;
i++;
```

Sulje samanlainen lohko while-silmukaksi:

 int lkm = 0;
 int i = 0;
 while ( i < luvut.Length )
 {
     if ( luvut[i] == luku ) lkm++;
     i++;
 }

Mallivastaus - while

    public static int Montako(int[] luvut, int luku)
    {
        int lkm = 0;
        int i = 0;
        while ( i<luvut.Length ) 
        {
            if ( luvut[i] == luku ) lkm++;
            i++;
        }
        return lkm;
    }

Kun olet saanut vastauksen valmiiksi, debuggaa sitä Visual Studiolla.

Mallivastaus - for

    public static int Montako(int[] luvut, int luku)
    {
        int lkm = 0;
        for (int i=0; i<luvut.Length; i++) 
        {
            if ( luvut[i] == luku ) lkm++;
        }
        return lkm;
    }

Kun olet saanut vastauksen valmiiksi, debuggaa sitä Visual Studiolla.

# hyotyd5t4

# d6

Demo 6

# d6tauno2

6 Tauno 2. Matriisin indeksit

Tarkoituksena on laskea tietyn ruudun naapureiden lukumäärä, ks alempana oleva kuva.

Tutustu ensin huolella demo 5:n sopulipeliin ja mieti miten laskit siinä naapureiden lukumäärän kullekin ruudulle. Naapureiden lukumäärän laskemiseksihan riittää laskea yhteen kussakin naapuriruudussa olevat luvut. Tällöin ei tarvita siihen mitään ehtolauseita.

Demo 5 sopulipelistä poiketen tässä naapureiksi lasketaan vaan "pääilmansuunnissa" olevat naapurit, eli suoraan yläpuolella, sivulla tai alapuolella olevat naapurit (max 4 kappaletta jos olla ruudukon laidalla). Alla olevassa mallikuvassa ruudun [1,2] naapurit ovat vihreällä.

Aluksi lasketaan naapurit vain ruudulle [1,2]:

# d5tauno21

Naapureiden osoitteet

Ruudun [1,2] (punainen) pääilmansuuntanaapureiden (vihreät) "osoitteet" ovat:
- yläpuolella: [0,2]
- vasemmalla: [1,1]
- oikealla [1,3]
- alapuolella [2,2]

Mallivastaus

    n += sukupolvi[0,2];
    n += sukupolvi[1,1];
    n += sukupolvi[1,3];
    n += sukupolvi[2,2];

Seuraavaksi muutetaan niin, että lasketaan naapurit yleiselle "sisäpisteelle" [iy,ix]. Edellinen tilanne saadaan siis tämän erikoistapauksena iy=1, ix=2. Reunapisteet ovat vielä tässä vaiheessa hankalampia, koska niillä on eri määrä naapuriruutuja.

# d6tauno22

Naapureiden osoitteet

Ruudun [ix,iy] pääilmansuuntanaapureiden “osoitteet” ovat:

yläpuolella: [iy-1,ix]
vasemmalla: [iy,ix-1]
oikealla [iy,ix+1]
alapuolella [iy+1,ix]

Mallivastaus

Kannattaa kirjoittaa niin, että jokaisessa kohdassa on laskutoimistus, niin kaikista riveistä tulee "samanlaisia":

    n += sukupolvi[iy-1,ix+0];
    n += sukupolvi[iy+0,ix-1];
    n += sukupolvi[iy+0,ix+1];
    n += sukupolvi[iy+1,ix+0];

Nyt lähdetään yleistämään tilannetta niin, että olisi jatkossa mahdollisimman helppo tehdä silmukka naapureiden laskemiseksi.

# d6tauno23

Miksi näin

Tavoitellaan tilannetta, jossa itse laskeminen on aina samanlaista, vain y ja x muuttuvat. Tässä ei pääse samanlaiseen säännönmukaisuuteen kun varsinaisessa Tauno 2-tehtävässä.

Mallivastaus

        y = -1; x = 0;
        n += sukupolvi[iy+y,ix+x];
        y =  0; x = -1;
        n += sukupolvi[iy+y,ix+x];
        y =  0; x =  1;
        n += sukupolvi[iy+y,ix+x];        
        y =  1; x =  0;
        n += sukupolvi[iy+y,ix+x];

Tästä pyritään tekemään silmukka niin, että laitetaan naapuriruutujen erokoordinaatit aputaulukkoon, ja käydään sieltä hakemassa äsken vakioina olleet arvot.

# d6tauno24

Erotaulukko

# erotkuva

Varsinainen Tauno 2-tehtävä on tarkoitus ratkaista sisäkkäisillä silmukoilla, mutta koska tässä naapureita on vähän, tehdään taulukko, jolla voidaan selvittää naapureiden indeksit. Toki tämä tapa toimisi "hätätilassa" myös oikeassa Tauno 2-tehtävässä, mutta taulukosta tulisi aika iso. Tosin tässä esitettävän tavan etuna on, että naapurina oleminen voidaan määritellä paljon monipuolisemmin. Voidaan esimerkiksi sanoa että 2 pykälää idässä oleva on myös naapuri (miten?).
Edellä oli jo jonkinlainen toistuva säännönmukaisuus, mutta koodissa
```
  y = -1; x = 0;
  n += sukupolvi[iy+y,ix+x];
  y =  0; x = -1; 
  ...
```
y:n ja x:n arvot vaihtelevat "epämääräisesti". Yritetään korjata tämä puute taulukolla, josta löytyvät nuo vastaavat y:n ja x:n arvot.

Tehdään taulukko, jossa on eri naapureiden koordinaatien suhteellinen ero tutkittavaan pisteeseen. Huomaa että matematiikasta poiketen pidetään y ensin.

      int[,] erot= {// 0  1  indeksit
                     {-1, 0},  // 0   yläpuolisen naapurin indeksien ero
                     { 0,-1},  // 1   vasemman naapurin indeksien ero
                     { 0, 1},  // 2   oikean naapurin indeksien ero
                     { 1, 0}   // 3   alapuolisen naapurin indeksien ero
                   };

nyt ensimmäinen y = -1; korvataan sillä, mistä sama -1 löytyy taulukosta,
vastaavasti x = 0; korvataan sillä, mistä 0 löytyy taulukosta

kirjoitetaan erot-taulukon avulla aikaisempi summa:

      y = erot[0,0]; x = erot[0,1]; // vrt y = -1; x = 0;
      n += sukupolvi[iy+y,ix+x];

      y = erot[1,0]; x = erot[1,1];
      n += sukupolvi[iy+y,ix+x];

      y = erot[2,0]; x = erot[2,1];
      n += sukupolvi[iy+y,ix+x];        

      y = erot[3,0]; x = erot[3,1];
      n += sukupolvi[iy+y,ix+x];

eli tästä löytyy tarvittava silmukka, kun otetaan kullakin kierroksella erot-taulukosta vastaava y ja x ero:
```
      y = erot[i,0]; x = erot[i,1];
      n += sukupolvi[iy+y,ix+x];
```

Mallivastaus

        int[,] erot= {{-1,0}, {0,-1}, {0,1}, {1,0}};
        for (int i=0; i<erot.GetLength(0); i++)
        {
            y = erot[i,0]; x = erot[i,1];
            n += sukupolvi[iy+y,ix+x];
        }

Korjataan koodia vielä niin, että voidaan laskea minkä tahansa ruudun naapurit. Jopa sellaisten, jotka ovat reilusti alueen ulkopuolella.

Aloitetaan muuttamalla edellistä laskua siten, että lasketaan sukupolvitaulukossa tarvittavat indeksit etukäteen tyyliin

 y = iy + erot[i,0];
 x = ix + ???;

jolloin summaa voidaan kirjoittaa:

 n += sukupolvi[y,x];

kunhan ensin ollaan varmoja, että y ja x ovat laillisia, eli esimerkin sukupolvitaulukossa välillä 0-3. Tietysti yleisessä taulukossa yläraja voi olla muukin.

# d6tauno25

Mallivastaus

        int[,] erot= {{-1,0}, {0,-1}, {0,1}, {1,0}};
        int maxy = sukupolvi.GetLength(0);
        int maxx = sukupolvi.GetLength(1);
        for (int i=0; i<erot.GetLength(0); i++)
        {
            y = iy + erot[i,0]; x = ix + erot[i,1];
            if ( y < 0 ) continue;
            if ( y >= maxy ) continue;
            if ( x < 0 ) continue;
            if ( x >= maxx ) continue;
            n += sukupolvi[y,x];
        }

# hyotyd6tauno2

# d6t2

6.2 Ehto ja etumerkin vaihtaminen

# d6t2a

Tynkä, kommentit ja testit

    /// <summary>
    /// Vaihdetaan parillisen luvun etumerkki
    /// </summary>
    /// <param name="luku">muutettava luku</param>
    /// <returns>parilliset luvut etumerkki vaihtuneena, parittomat sellaisenaan</returns>
    /// <example>
    /// <pre name="test">
    ///   VaihdaParillisenEtumerkki(-8) === 8;
    ///   VaihdaParillisenEtumerkki(0) === 0;
    ///   VaihdaParillisenEtumerkki(8) === -8;
    ///   VaihdaParillisenEtumerkki(1) === 1;
    ///   VaihdaParillisenEtumerkki(-1) === -1;
    /// </pre>
    /// </example>
    public static int VaihdaParillisenEtumerkki(int luku)
    {
        return 0;
    }

Miten testataan ja miten etumerkki vaihdetaan

Luvun parillisuutta voidaan testata kokeilmalla jakaa se kakkosella ja jos jakojäännös on nolla, on luku parillinen:

luku % 2 == 0

luvun etumerkin vaihtamiseen riittää ihan vastaluku:

luku = -luku;

Mallivastaus

        public static int VaihdaParillisenEtumerkki(int luku)
        {
            if ( luku % 2 == 0 ) return -luku;
            return luku;
        }

# d6t2b

Tynkä, kommentit ja testit

        public static int VaihdaParillisenEtumerkki(int luku)
        {
            if ( luku % 2 == 0 ) return -luku;
            return luku;
        }
        
        
        /// <summary>
        /// Lisätään lukuun 10 ja palautetaan tulos sellaisenaan jos se on parillinen,
        /// muuten tuloksen vastaluku.
        /// </summary>
        /// <param name="???">?????</param>
        /// <returns>luku+10 jos parillinen, muuten -(luku+10)</returns>
        /// <example>
        /// <pre name="test">
        ///   VaihdaParittomanSummanEtumerkki(-8) === 2;
        ///   VaihdaParittomanSummanEtumerkki(-10) === 0;
        ///   VaihdaParittomanSummanEtumerkki(-1) === -9;
        ///   VaihdaParittomanSummanEtumerkki(-12) === -2;
        ///   VaihdaParittomanSummanEtumerkki(-11) === 1;
        ///   VaihdaParittomanSummanEtumerkki(3) === -13;
        /// </pre>
        /// </example>
        public static int VaihdaParittomanSummanEtumerkki(int luku)
        {
            return 0;
        }

Summa ja testaaminen

Kun luku on summattu, pitäisi oikeastaan tehdä edellisestä funktiosta sellainen, joka vaihtaa tuloksen parittoman tapauksessa. Mutta koska edellinen funkiot kääntää aina parillisen arvon, niin

    int a = 2;
    VaihdaParillisenEtumerkki(a) === -2
    -VaihdaParillisenEtumerkki(a) === 2
    
    int b = 3;
    VaihdaParillisenEtumerkki(b) === 3
    -VaihdaParillisenEtumerkki(b) === -3

eli voidaan käyttää edellisen funktion palauttama tulos ja palauttaa sen vastaluku kaikissa tapauksissa. Eli yhtään uutta ehtolausetta ei tarvitse kirjoittaa.

Mallivastaus

Kopioi edellisen tehtävän mallivastaus tähän etupuolelle ja sitten

        public static int VaihdaParittomanSummanEtumerkki(int luku)
        {
            int summa = luku + 10;
            int tulos = -VaihdaParillisenEtumerkki(summa);
            return tulos;
        }

Koska tulokselle on sijoitettu tuo -VaihdaParillisenEtumerkki(summa), niin se voidaan suoraan kirjoittaa sinne missä käytetään tulos-muuttujaa ja silloin tulos-muuttuja muuttuu tarpeettomaksi:

        public static int VaihdaParittomanSummanEtumerkki(int luku)
        {
            int summa = luku + 10;
            return -VaihdaParillisenEtumerkki(summa);
        }

Toisaalta sama summa-muuttujan kanssa ja silloin sekin on tarpeeton:

        public static int VaihdaParittomanSummanEtumerkki(int luku)
        {
            return -VaihdaParillisenEtumerkki(luku+10);
        }

Ensimmäinen muoto on hyvä jos koodia joutuu debuggaamaan, koska silloin näkee välivaiheet. Viimeistäkin pitää osata lukea, mutta jokainen voi päättää mitä muotoa itse haluaa kirjoittaa.

# hyotyd6t2

# d6t3

6.3 Etsiminen

Tämän tehtävän ymmärtäminen, kuten kaikkien muidenkin, vaatii sen, että käsin lasketaan eri luvuille jakojäännöksiä ja kirjoitetaan niitä lukujen viereen paperille ja sitten itse etsitään haluttua tulosta. Kun tätä on tehnyt riittävän usein, voi ymmärtää ongelman ja sitten pystyä miettimään sitä ohjelmaksi.

Tämän tehtävän vaikeusaste on sama kuin demo 6:n tehtävä 3:ssa vaadittava EtsiLahin. Molemmissa mitataan "paremmuutta" jollain tavalla ja etsitään sitä alkiota, jolla on mittarin mukana paras tulos.

# d6t3etsiminen

Esittelyrivi, tynkä, kommentit ja testit

        /// <summary>
        /// Etsitään luku, jolla on pienin jakojäännös kun se jaetaan jakajalla.
        /// </summary>
        /// <param name="luvut">taulukko josta etsitään</param>
        /// <param name="jakaja">jakaja jolla jaetaan, ei saa olla 0</param>
        /// <returns>luku jolla pienin jakojäännös</returns>
        /// <example>
        /// <pre name="test">
        ///   int[] luvut = {2344, 1023, 97, 2343, 1236};
        ///   EtsiLukuJollaPieninJakojaannos(luvut, 7) === 1023; // jj: 6 1 5 6
        ///   EtsiLukuJollaPieninJakojaannos(luvut, 6) === 1236; // jj: 4 3 1 3
        ///   EtsiLukuJollaPieninJakojaannos(luvut, 4) === 2344; // jj: 0 3 1 3 
        ///   int[] luvut2 = {-5, -9, -11};
        ///   EtsiLukuJollaPieninJakojaannos(luvut2, 10) === -9; // jj: -5 -9 -1  
        ///   EtsiLukuJollaPieninJakojaannos(luvut2, 4) === -11; // jj: -1 -1 -3
        ///   EtsiLukuJollaPieninJakojaannos(luvut2, 2) === -5;  // jj: -1 -1 -1
        /// </pre>
        /// </example>
        public static int EtsiLukuJollaPieninJakojaannos(int[] luvut, int jakaja)
        {
            return 0;
        }

Ongelman hahmottaminen

Yleensä kaikissa etsimisongelmissa on tarkoitus löytää joku "voittaja". Joskus etsitään pienintä, suurinta tai ehkä itse lukua. Usein etsimisehtona on jokin muu kuin luvun suora arvo. Ja tällöin "hyvyyttä" mittataan jollakin mittarilla, joka antaa jonkin selkeän tuloksen. Esim mittari voisi olla "kuinka kaukana" tms. Nyt mittarina on se, mikä on luvun jakojäännös ja voittaja on se, jolla on pienin jakojäännös. Tällöin voittamiseen liittyy voittajan tulos. Eli normaalin voittajan ylläpitämisen lisäksi, täytyy pitää yllä voittajan tulosta. Itse etsiminen tehdään normaalilla silmukalla

voittajan seuraamiseen tarvitavat muuttujat alustetaan niin, että kuka tahansa voittaa ne, esim:

      int voittaja = int.MinValue;
      int voittajanTulos = int.MaxValue; // tämän voittaa kuka vaan

itse silmukka tehdään kuten aina etsimistehtävissä. Kun tutkittava luku (tai muu alkio) on saatu, muodostetaan sille "tulos", jota verrataan voittajan tulokseen:
```
      int tulos = luku % jakaja; // % antaa jakojäännöksen
      if ( tulos < voittajanTulos )
```
jos voitetaan, eli tässä tehtävässä pienempi on parempi. vaihdetaan voittaja ja sen tulos:
```
          voittaja = luku;
          voittajanTulos = tulos;
```
lopulta kun kaikki ovat saaneet yrittää, löytyy noista muuttujista voittaja ja voittotulos. Niitä käsitellään lopuksi tarvittavalla tavalla, eli tässä funktiossa palautetaan voittaja.

Mallivastaus (melkein)

    public static int EtsiLukuJollaPieninJakojaannos(int[] luvut, int jakaja)
    {
        int voittaja = int.MinValue;
        int voittajanTulos = int.MaxValue; // tämän voittaa kuka vaan
        for (int i=0; i<luvut.Length; i++) 
        {
            int luku = luvut[i];
            int tulos = luku % jakaja;
            // Console.WriteLine($"{luku} {tulos}"); // kokeilua varten
            if ( tulos < voittajanTulos )
            {
                voittaja = luku;
                voittajanTulos = tulos;
            }
        }
        return voittaja;
    }

Mallivastaus (melkein) - foreach

        ...
        foreach (int luku in luvut) 
        {
            int tulos = luku % jakaja;
            if ( tulos < voittajanTulos )
            {
                voittaja = luku;
                voittajanTulos = tulos;
            }
        }
        ...

Mitä asioita mallivastauksessa on käsittelemättä, testaamatta ja dokumentoimatta?

Puuttuvat tarkastukset

Ei ole erikseen tarkastettu että onko taulukko tyhjä. Tästä tosin selvitään sillä, että funktion nykyinen toteutus palauttaa int.MinValue jos silmukkaa ei tehdä yhtään kertaa, mutta tämä olisi silloin syytä erikseen dokumentoida ja testata.
ei ole tarkistettu että jaetaanko nollalla. On vaikea sanoa mikä olisi oikea vastaus tässä tapauksessa. Jos dokumentoidaan että tällöinkin palautetaan int.MinValue, niin sekin olisi syytä testata.
kumpikin tapaus voidaan laittaa heittämään poikkeus (nollalla jako heittääkin se jo nyt) mutta tämäkin olisi silloin syytä kommentoida ja testata.

jos pidättäydytään nykyisessä koodissa, niin tehtäisiin muutokset:

  /// <summary>
  /// Etsitään luku, jolla on pienin jakojäännös kun se jaetaan jakajalla.
  /// Tyhjän taulukon tapauksessa palautetaan int.MinValue.
  /// Jos jakaja on nolla heitetään poikkeus DivideByZeroException.
  /// </summary>

ja testeihin lisää:

  ///   EtsiLukuJollaPieninJakojaannos(new int[0], 2) === int.MinValue;
  ///   EtsiLukuJollaPieninJakojaannos(luvut2, 0) === -5;  #THROWS DivideByZeroException

Tuo #THROWS-lause kertoo että funktion kuuluisi tässä tapauksessa heittää perässä mainittu poikkeus. Jos se EI heitä, niin testi ei mene läpi. Paluuarvolla ei ole tässä testissä merkitystä, koska poikkeuksen tapauksessa palautukseen asti ei koskaan päästä. Lue halutessasi tästä lisää.

jos halutaan palauttaa 0:lla jaon tapauksessa sama kuin tyhjällä taulukolla, niin muutetaan sitten kommentit tämän mukaiseksi ja testissä
```
  ///   EtsiLukuJollaPieninJakojaannos(luvut2, 0) === int.MinValue;
```
ja sitten funktion alkuun:
```
    if ( jakaja == 0 ) return int.MinValue;
```

vielä yksi vaihtoehto olisi tuoda funktiolle parametrina arvo, joka palautetaan virhetilanteissa, eli lisättäisiin parametrilistaan:

  public static int EtsiLukuJollaPieninJakojaannos(int[] luvut, int jakaja, int virhe=int.MinValue)

testeihin lisää:

  ///   EtsiLukuJollaPieninJakojaannos(new int[0], 2, -99) === -99;
  ///   EtsiLukuJollaPieninJakojaannos(luvut2, 0, -99) === -99;

ja toteutuksen alkuun:

      if ( jakaja == 0 || luvut.Length == 0 ) return virhe;

# hyotyd6t3

# d7

Demo 7

# d7t1

7.1 Vektoreita taulukossa

Tässä esimerkissä on tehty Jypelin Vector luokkaa vastaava minimaalinen versio, jossa ainoa mikä toimii on ToString().

HUOM! Vaikka tässä harjoituksessa tulostetaankin pisteitä, ei vastaavassa demotehtävässä ole missään tapauksessa tarkoitus tulostaa, vaan luoda palloja, joiden keskipiste on paikassa p (tai pisteet[i] jos ei käytetä apumuuttujaa).

# d7t1pisteettaulukossa

Esittelyrivi, kommentit ja tynkä

Tässä Vector-luokassa on metodi ToString joka muuttaa lukuparin merkkijonoksi ja siten se voidaan tulostaa sen avulla. Eli voitaisiin kirjoittaa myös

Console.WriteLine(p.ToString());

mutta jos käytetään oliota sellaisessa paikassa jossa tarvitaan merkkijonoa, kutsutaan ToString automaattisesti.

    /// <summary>
    /// Tulostetaan taulukossa olevat pisteet kukin omalle rivilleen
    /// </summary>
    /// <param name="pisteet">Tulostettavat pisteet</param>
    public static void TulostaPisteet(Vector[] pisteet)
    {
            Vector p = pisteet[0];  Console.WriteLine(p);
    }

Taunomainen ratkaisu

Koska p on jo kerran esitelty, ei sen esittelyä enää saa kopioida muille riveille. Tai kukin rivi pitäisi tehdä omaksi lohkokseen tyyliin:

        {  Vector p = pisteet[0];  Console.WriteLine(p); }

Tehdään kuitenkin neljän pisteen tulostus aluksi ilman lohkoja:

    public static void TulostaPisteet(Vector[] pisteet)
    {
            Vector p = pisteet[0];  Console.WriteLine(p);
                   p = pisteet[1];  Console.WriteLine(p);
                   p = pisteet[2];  Console.WriteLine(p);
                   p = pisteet[3];  Console.WriteLine(p);
    }

Mallivastaus silmukalla

Muutetaan juosevat numerot indekseiksi ja sitten silmukaksi:

    /// <summary>
    /// Tulostetaan taulukossa olevat pisteet kukin omalle rivilleen
    /// </summary>
    /// <param name="pisteet">Tulostettavat pisteet</param>
    public static void TulostaPisteet(Vector[] pisteet)
    {
        for (int i = 0; i < pisteet.Length; i++)
        {
            Vector p = pisteet[i];
            Console.WriteLine(p);
        }
    }

Mallivastaus foreach-silmukalla ilman apumuuttujaa

    public static void TulostaPisteet(Vector[] pisteet)
    {
        foreach (Vector p in pisteet)
            Console.WriteLine(p);
    }

# hyotyd7t1

# d7t2

7.2 Arvo lukuja taulukkoon

# d7t2arvolukuja

Esittelyrivi ja tynkä

    public static double[] ArvoLukuja(int n, double x1, double x2)
    {
        double[] t = new double[n];
        return t;
    }

Mallivastaus

    public static double[] ArvoLukuja(int n, double x1, double x2)
    {
        double[] t = new double[n];
        for (int i = 0; i < t.Length; i++)
        {
            double x = RandomGen.NextDouble(x1, x2);
            t[i] = x;
        }
        return t;
    }

# hyotyd7t2

# d7t3

7.3 Etsi vektoritaulukosta

# d7t3indeksilahella

Esittelyrivi, tynkä, kommentit ja testit

    /// <summary>
    /// Etsitään taulukosta ensimmäisen pisteen paikka, joka on etsittävästä korkeintaan etaisyyden paassa.
    /// </summary>
    /// <param name="pisteet">taulokko josta etsitään</param>
    /// <param name="etsittava">piste jonka lähellä olevaa etsitään</param>
    /// <param name="etaisyys">etäisyys jonka alle oleva piste hyväksytään</param>
    /// <returns>lähellä oleva pisteen indkesi jos löytyy, muuten -1</returns>
    /// <example>
    /// <pre name="test">
    ///  Vector[] pisteet = { new Vector(3, 1), new Vector(9, 2), new Vector(2, 9), new Vector(12, 5) };
    ///  EtsiPisteenPaikka(pisteet, new Vector(3,1), 0.1) === 0;
    ///  EtsiPisteenPaikka(pisteet, new Vector(8,3), 2.0) === 1;
    ///  EtsiPisteenPaikka(pisteet, new Vector(3,8), 2.0) === 2;
    ///  EtsiPisteenPaikka(pisteet, new Vector(11,5), 1.5) === 3;
    ///  EtsiPisteenPaikka(new Vector[0], new Vector(8,3), 2.0) === -1;
    /// </pre>
    /// </example>
    public static int EtsiPisteenPaikka(Vector[] pisteet, Vector etsittava, double etaisyys)
    {
        return -1;
    }

Mallivastaus

public static int EtsiPisteenPaikka(Vector[] pisteet, Vector etsittava, double etaisyys)
    {
        for (int i = 0; i < pisteet.Length; i++)
        {
            Vector p = pisteet[i];
            if (Vector.Distance(p, etsittava) <= etaisyys) return i;
        }
        return -1;
    }

# hyotyd7t3

# d7t5

7.5 Kirjainten tutkiminen

Alla oleva tehtävä on oikestaan sama kuin aikaisempi Taulukot silmukalla-tehtävä. Kannattaa ensin katsoa sen vinkit ja yrittää tätä ilman vinkkejä.

# laskeisot

Esittelyrivi, tynkä, kommentit ja testit

    /// <summary>
    ///  Lasketaan jonossa olevien isojen kirjainten lukumäärä
    /// </summary>
    /// <param name="jono">tutkittava merkkijono</param>
    /// <returns>isojen kirjainten lukumäärä</returns>
    /// <example>
    /// <pre name="test">
    ///   LaskeIsot("Kissa") === 1;
    ///   LaskeIsot("kissa") === 0;
    ///   LaskeIsot("kiva Kissa Istuu Puussa") === 3;
    ///   LaskeIsot("iso LopussA") === 2;
    /// </pre>
    /// </example>
    public static int LaskeIsot(string jono)
    {
        return 0;
    }

Funktion toteutus

Char-luokan dokumentaatiosta löytyy metodi IsUpper, jolla voidaan tarkistaa onko kyseessä iso kirjain. Käydään läpi kaikki jonon merkit ja katsotaan jokaisen kohdalla onko kyseessä iso kirjain. Jos on, listään laskuria.

    public static int LaskeIsot(string jono)
    {
        int lkm = 0;
        for (int i=0; i<jono.Length; i++)
        {
            char merkki = jono[i];
            if ( Char.IsUpper(merkki) ) lkm++;
        }
        return lkm;
    }

# hyotyd7t5

# d7t6a

7.6 Taulukon vastinalkioiden summataulukko

# Vastinalkiot

Esittelyrivi ja tynkä

    public static double[] Summa(double[] a, double[] b)
    {
        return new double[0];
    }

Tulostaulukon luominen

Vastaavasti kuin vaikkapa alkioden summan laskemisesa, tarvitaan tulosta varten apumuuttuja, tarvitaan tässäkin vastaava.

Koska tulos pitää saada uuteen taulukkoon, pitää aluksi luoda tulostaulukko. Ensin sille pitää saada sopiva koko. Eli selvitetään kumpiko taulukoista a vai b on lyhyempi. Tämä voitaisiin tehdä normaailla if-lauseella, mutta tähän on olemassa valmiskin funktio:

     int n = Math.Min(a.Length, b.Length);

Kun tulostaulukon koko on saatu selville, luodaan itse summaa varten tarvittava tulostaulukko:

    double[] s = new double[n];

Sitten onkin jäljellä enää normaali kaikkien taulukon alkioiden läpikäynti. Jos toinen taulukko on pidempi, niin sen loput alkiot jätetään käsittelemättä.

    for (int i = 0; i < n; i++)
    {
        // Mitä tehdään alkiolle
    }

Mallivastaus

    public static double[] Summa(double[] a, double[] b)
    {
        int n = Math.Min(a.Length, b.Length);
        double[] s = new double[n];
        for (int i = 0; i < n; i++)
            s[i] = a[i] + b[i];
        return s;
    }

# hyotyd7t6a

# d7t6b

7.6 Matriisin palauttamien

# matriisinkertominenvakiolla

Esitelyrivi ja tynkä

    public static double[,] Kerro(double[,] a, double kerroin)
    {
        return new double[0, 0];
    }

Tulosmatriisin luominen

Koska tuloksena pitää palauttaa uusi matriisi, pitää se ensin luoda:

        double[,] m = new double[riveja, sarakkeita];

Tätä varten tarvitaan tietysti ensin normaalisti selvittää tarvittavat rivi- ja sarakemäärät:

        int riveja = a.GetLength(0);
        int sarakkeita = a.GetLength(1);

Alkioiden läpikäynti

Seuraavaksi käydään normaalilla tavalla läpi kaikki alkiot:

    for (int iy = 0; iy < riveja; iy++)
        for (int ix = 0; ix < sarakkeita; ix++)
        {
            // Mitä tehdään alkioille???
        }

Mallivastaus

    public static double[,] Kerro(double[,] a, double kerroin)
    {
        int riveja = a.GetLength(0);
        int sarakkeita = a.GetLength(1);
        double[,] m = new double[riveja, sarakkeita];
        for (int iy = 0; iy < riveja; iy++)
            for (int ix = 0; ix < sarakkeita; ix++)
                m[iy, ix] = kerroin * a[iy, ix];
        return m;
    }

# hyotyd7t6b

Demo 8

# d8t1

8.1 Jaollisuus

Pelissä Saalista Silakka on pisteiden suhteen sääntö, että pelin voi voittaa vain jos:

Pisteiden lukumäärä on 3,6,9,.. eli jaollinen 3:lla
Pisteitä on enemmän kuin 0.
Pisteitä ei ole 50, 100, 150,... eli lukumäärä ei ole jaollinen 50:llä

# jaollisuus

Esittelyrivi, tynkä, kommentit ja testit

Vaikka funktio ei olekkaan maailman yleiskäyttöisin, voidaan se silti julistaa public-näkyvyysmääreellä. Staattinen se on ilman muuta, koska laskemiseen ei muuta tarvita kuin pistemäärä. Jo nimi VoikoVoittaa viittaa sihen, että tulos pitäisi olla totuusarvoinen. Parametrina on pistemäärä. Kommentteihin kerrotaan mitä funktio tekee. Sitten testeihin määritelmän mukaisia testejä niin, että vähintään kerran testataan kutakin tapausta. Tässä vaiheessa ei vielä toteutuksesta kannata murehtia. Pistemärän pitäisi olla kokonaisluku (int) mikä riittääkin tälle kurssille, mutta jos ollaan tarkkoja, niin kannattaa estää negatiiviset luvut laittamalla tyypiksi uint (unsigned int, eli etumerkitön kokonaisluku).

    /// <summary>
    ///  Tutkitaan voiko pelissä voittaa.
    ///  Voiton ehtona on että pistemäärä on kolmella jaollinen, mutta
    ///  ei 50 jaollinen.  Myöskään 0 ei kelpaa.
    /// </summary>
    /// <param name="pisteet">pelissä saadut pisteet</param>
    /// <returns>true jos pelissä voi voittaa</returns>
    /// <example>
    /// <pre name="test">
    ///   VoikoVoittaa(0) === false; 
    ///   VoikoVoittaa(1) === false; 
    ///   VoikoVoittaa(3) === true; 
    ///   VoikoVoittaa(5) === false; 
    ///   VoikoVoittaa(12) === true; 
    ///   VoikoVoittaa(50) === false; 
    ///   VoikoVoittaa(100) === false; 
    ///   VoikoVoittaa(300) === false; 
    /// </pre>
    /// </example>
    public static bool VoikoVoittaa(uint pisteet)
    {
        return false;
    }

Ongelman hahmottamista

Jos kokonaisluku jaetaan kolmella, se voidaan esittä kokonaisosana ja jakojäännöksena. Esimeriksi

\[ 11/3 = 3 + 2/3 \]

Useissa kielissä jakolasku (/) antaa tuon kokonaisosan ja modulo (%) jakojäännöksen. (Prosenttimerkki lienee valittu koska se muistuttaa jakomerkkiä kun unohdetaan pylpyrät?). Luku on jaollinen kolmella jos sen jakojäännös kolmella jaettuna on nolla. Eli jos lauseke

luku % 3 == 0

on tosi. Vastaavasti tietysti 50:llä jaollisuus. Tehtävässä varma "häviö" tulee, jos pistemäärä on jaollinen 50:llä, eli se kannattaa testata ensin ja palauttaa siinä tapauksessa että voiton mahdollisuus on false. Toisaalta pitäisi myös katsoa tuo että onko pistemäärä eri kuin 0. Mutta koska 0 on jaollinen 50:llä (jakojäännös on nolla), tulee se oikeastaan testattua jo tuon 50:n yhteydessä. Tämän jälkeen varma tapaus voittomahdollisuuteen on kolmella jaollisuus, eli kokeillaan se ja palautetaan siinä tapauksessa true. Jos tämä ei onnistu, palautetaan false.

Malliratkaisu

    public static bool VoikoVoittaa(int pisteet)
    {
        if ( pisteet % 50 == 0 ) return false;
        if ( pisteet % 3 == 0 ) return true;
        return false;
    }

Toisenlainen malliratkaisu

Koska tarkoituksena on palauttaa tosi tai epätosi, voidaan muotoilla totuusarvoinen lauseke, jonka arvo palautetaan sellaisenaan:

    public static bool VoikoVoittaa(uint pisteet)
    {
        return ( pisteet % 50 != 0 && pisteet % 3 == 0 );
    }

# hyotyd8t1

# d8t2

8.2 Luvun sanallinen vastike

Pelissä Nappaa naakka on keräyttyjen naakkojen lukumäärän mukaan seuraavat arvostelut:

0-3: umpisurkeaa
4: aloittelija
5: kohtuullinen nappaaja
6-7: mestari naakan nappaaja
8: naakan nappaajien kuningas
9-: huijari, näin montaa naakkaa ei ole pelissä

# naakkaif

Esittelyrivi, tynkä, kommentit ja testit

Muuten kuten aina, paluuarvo on tyyppiä string:

    /// <summary>
    /// Palautetaan sanallinen arvostelu pelaajn suoriutumisesta
    /// </summary>
    /// <param name="pisteet">pelaajan pisteet</param>
    /// <returns>arovstelu pelaajan suoriutumisesta</returns>
    /// <example>
    /// <pre name="test">
    ///    NaakkaArvostelu(0) === "umpisurkeaa"
    ///    NaakkaArvostelu(3) === "umpisurkeaa"
    ///    NaakkaArvostelu(4) === "aloittelija"
    ///    NaakkaArvostelu(5) === "kohtuullinen nappaaja"
    ///    NaakkaArvostelu(6) === "mestari naakan nappaaja"
    ///    NaakkaArvostelu(7) === "mestari naakan nappaaja"
    ///    NaakkaArvostelu(8) === "naakan nappaajien kuningas"
    ///    NaakkaArvostelu(9) === "huijari, näin montaa naakkaa ei ole pelissä"
    ///    NaakkaArvostelu(200) === "huijari, näin montaa naakkaa ei ole pelissä"
    /// </pre>
    /// </example>
    public static string NaakkaArvostelu(uint pisteet)
    {
         return "umpisurkeaa";
    }

Mallivastaus

    public static string NaakkaArvostelu(uint pisteet)
    {
        if ( pisteet < 4 ) return "umpisurkeaa";
        if ( pisteet == 4 ) return "aloittelija";
        if ( pisteet == 5 ) return "kohtuullinen nappaaja";
        if ( 6 <= pisteet && pisteet <= 7 ) return "mestari naakan nappaaja";
        if ( pisteet == 8 ) return "naakan nappaajien kuningas";
        return "huijari, näin montaa naakkaa ei ole pelissä";
    }

# naakkacase

Mallivastaus

    public static string NaakkaArvostelu(uint pisteet)
    {
        switch (pisteet) 
        {
            case 0:
            case 1:
            case 2:
            case 3: return "umpisurkeaa";
            case 4: return "aloittelija";
            case 5: return "kohtuullinen nappaaja";
            case 6:
            case 7: return "mestari naakan nappaaja";
            case 8: return "naakan nappaajien kuningas";
            
        }
        return "huijari, näin montaa naakkaa ei ole pelissä";
    }

# naakkataulukko

Mallivastaus

    public static string NaakkaArvostelu(uint pisteet)
    {
        string[] arvio = {"aloittelija", "kohtuullinen nappaaja",
                          "mestari naakan nappaaja", "mestari naakan nappaaja",
                          "naakan nappaajien kuningas"};
        if ( pisteet < 4) return "umpisurkeaa";
        if ( pisteet > 8 ) return "huijari, näin montaa naakkaa ei ole pelissä";
        return arvio[pisteet-4];
    }

# hyotyd8t2

# d9

Demo 9

# d9t1

9.1 Montako samojen joukkoa

# d9t1samojenlaskeminen

Esittelyrivi, tynkä, kommentit ja testit

Kirjoitetaan kommentit ja normaali tynkä opituilla tavoilla. Testeihin kannattaa laittaa tyhjä joukko, sellainen missä kaikki luvut ovat samoja ja ainakin yksi yhden alkion joukko. Kannattaa myös testata tilanteet, joissa alkaa ja loppuu yhden alkion joukolla.

/// <summary>
/// Lasketaan joukossa olevien samoista luvuista muodostuvien
/// osajoukkojen määrä.  Yhden luvun joukkoja ei lasketa.
/// </summary>
/// <param name="luvut">tutkittavien lukujen joukko</param>
/// <returns>osajoukkojen lukumäärä</returns>
/// <example>
/// <pre name="test">
///   int[] luvut = {3,3, 4,4,4 ,1, 2,2, 9,9, 1, 9,9};
///   SamojenJoukkojenMaara(luvut) === 5;
///   SamojenJoukkojenMaara(new int[]{1}) === 0;
///   SamojenJoukkojenMaara(new int[]{1,1}) === 1;
///   SamojenJoukkojenMaara(new int[]{1,2}) === 0;
///   SamojenJoukkojenMaara(new int[]{1,1,1,9}) === 1;
///   SamojenJoukkojenMaara(new int[]{1,1,9,9}) === 2;
///   SamojenJoukkojenMaara(new int[]{1,9,9,9}) === 1;
///   SamojenJoukkojenMaara(new int[]{}) === 0;
/// </pre>
/// </example>
public static int SamojenJoukkojenMaara(int[]luvut) 
{
    return 0;
}

Ratkaisun hahmottelua

Tarvitaan yksi laskuri, jolla lasketaan löytyneiden osajoukkojen määrä, olkoon se vaikka lkm. Lähtötilanteessa ei ole yhtään löytynyttä osajoukkoa. Toinen laskuri tarvitaan siihen, millä lasketaan peräkkäisten samojen alkioiden määrää. Jos joukossa on yksikin alkio, on peräkkäisten määrä lähtötilanteessa 1. Eli tehdään apumuuttujat:

        int lkm = 0;
        int samoja = 1;

Periaattessa jatkossa verrataan aina lukuja

luvut[0] == luvut[1]
luvut[1] == luvut[2]
luvut[2] == luvut[3]
 ...

Eli tyyliin:

luvut[i-1] == luvut[i]

Kun itse silmukkaa aloitetaan paikasta 1, voidaan verrata nykyistä alkiota edelliseen koska edellinen on olemassa kierroksella i=1. Silmukassa katsotaan onko nykyinen alkio sama kuin edellinen ja jos on, niin samojen määrä kasvaa:

        for (int i=1; i<luvut.Length; i++)
        {
            if ( luvut[i-1] == luvut[i] ) samoja++;

Peräkkäiset eivät samoja

Vastaavasti jos peräkkäiset eivät ola samoja, alkaa laskeminen alusta. Mutta sitä ennen kannattaa katso löytyikö tätä ennen samoja peräkkäisiä jolloin lukumäärä kasvaa;

        else
        {
            if ( samoja > 1 ) lkm++;
            samoja = 1;
        }

Periaattessa homma olisi valmis ja silmukan jälkene lukumäärä olisi selvillä ja se voitaisiin palauttaa:

        return lkm;

Mutta?

Paitsi jos kävisi niin "huonosti", että samat luvut ovat joukon lopussa, niin viimeisellä (tai ainoalla) joukolla ei käytäisi lainkaan else-osassa ja lukumäärä jäisi kasvattamatta. Siksi silmukan jälkeen on vielä lisättävä tarkistus siitä, että onko menossa keskeneräinen samojen joukko:

        if ( samoja > 1 ) lkm++;

Mallivastaus

    public static int SamojenJoukkojenMaara(int[]luvut) 
    {
        int lkm = 0;
        int samoja = 1;
        for (int i=1; i<luvut.Length; i++)
        {
            if ( luvut[i-1] == luvut[i] ) samoja++;
            else
            {
                if ( samoja > 1 ) lkm++;
                samoja = 1;
            }
        }
        if ( samoja > 1 ) lkm++;
        return lkm;
    }

Mallivastaus aloittaen 0:sta

Tässä tehtävässä onnistuttiin aika hyvin aloittamaan niin, että indeksi alkoi 1:stä ja siten oli mahdollista katsoa yhtä alkiota taaksepäin. Joskus ongelmaa voidaan myös lähestyä niin, että pidetään kirjaa edellisestä arvosta ja silloin taulukosta riittää katsoa vain nykyistä arvoa ja voidaan aloittaa 0:sta. Ensimmäistä kierrosta varten tosin pitää edellinen alustaa niin, ettei se ole sama muiden lukujen kanssa. Valinta tosin syö yhden mahdollisen luvun pois joukosta:

    public static int SamojenJoukkojenMaara(int[]luvut) 
    {
        int lkm = 0;
        int samoja = 0;
        int edellinen = int.MinValue;
        for (int i=0; i<luvut.Length; i++)
        {
            if ( edellinen == luvut[i] ) samoja++;
            else
            {
                if ( samoja > 1 ) lkm++;
                samoja = 1;
                edellinen = luvut[i];
            }
        }
        if ( samoja > 1 ) lkm++;
        return lkm;
    }

Mallivastaus foreach

Kun päästiin aloittamaan nollasta, käydään itse asiassa kaikki luvut läpi ja koska indeksi sinällään ei tarvita mihinkään, voidaan käyttää myös foreach-silmukkaa:

    public static int SamojenJoukkojenMaara(int[]luvut) 
    {
        int lkm = 0;
        int samoja = 0;
        int edellinen = int.MinValue;
        foreach (int luku in luvut)
        {
            if ( edellinen == luku ) samoja++;
            else
            {
                if ( samoja > 1 ) lkm++;
                samoja = 1;
                edellinen = luku;
            }
        }
        if ( samoja > 1 ) lkm++;
        return lkm;
    }

Mallivastaus ilman silmukan jälkeistä korjausta

Toisaalta tehtävää voidaan ajatella niin, että silloin kun samojen määrä on kasvamassa, niin ensimmäisellä kasvatuksellahan alkaa uusi joukko. Jos lukumäärää muutetaan tällöin, niin ei tarvitse silmukan jälkeen huolehtia asioista. Koska vain silloin kun samoja kasvaa, on mahdollista että on uuden joukon alku. Tämä ratkaisu voisi olla myös jonkin indeksiin perustuvan mallinkin yhteydessä, eli tämä ei sinällään liitty foreach-silmukkaan.

public static int SamojenJoukkojenMaara(int[]luvut) 
{
    int lkm = 0;
    int samoja = 0;
    int edellinen = int.MinValue;
    foreach (int luku in luvut)
    {
        if ( edellinen == luku ) 
        {
            if ( samoja == 1 ) lkm++;
            samoja++;
        }
        else
        {
            samoja = 1;
            edellinen = luku;
        }
    }
    return lkm;
}

Jos samoja++ pistettäisiin ennen if-lausetta, mitä muuta pitäisi muuttaa? Nörtti voisi jopa jättää erillisen kasvatusrivin pois ja kirjoittaa:

        if ( samoja++ == 1 ) lkm++;

Miksi tämäkin toimisi? Tai

        if ( ++samoja == 2 ) lkm++;

# d9t2

9.2 Vektorit ja viivat

Piirrä seuraavan kuvan mukaiset portaat viivoilla. Eli tee aliohjelma PiirraViiva niin, että se aloittaa viivan parametrina viedystä pisteestä ja piirtää se parametrina vietyyn suuntaan. Lopuksi palautetaan piirretyn viivan loppupiste. Ideana on että, kun viivan piirtävä aliohjelma aina palauttaa tiedon siitä mihin lopetti, niin seuraava viiva voidaan suoraan aloittaa tästä.

# d9t2viivatcache

# d9t2viivat

Esittelyrivi ja tynkä

Pääohjelman kutsusta nähdään että aliohjelman (sanotaan sitä aliohjelmaksi vaikka se palauttaakin arvon, koska sillä on merkittävä sivuvaikutus: se lisää peliin viivan) pitää palauttaa Vector-tyyppinen arvo. Muuten parametrit, niiden tyypit ja nimet kuten ennenkin. Tyngäksi kelpaa aluksi ihan pisteen palauttaminen.

    public static Vector PiirraViiva(PhysicsGame peli, Vector piste, Vector suunta)
    {
        return piste; 
    }

Tämä koodi kääntyy nyt, mutta ei luonnollisesti piirrä mitään.

Viivan pituus ja leveys

Aloitetaan sillä, että yritetään laskea tarvittavalla viivalle tiedot niin, että se voidaan piirtää suorakaiteena. Jos suunta on x-akselin suunta (vektori 1,0), niin pitäisi saada

w = VIIVANPITUUS
h = VIIVANLEVEYS

ja vastaavasti jos viiva pitää piirtää y-akselin suuntaan (vektori 0,1), niin vastaavasti

w = VIIVANLEVEYS
h = VIIVANPITUUS

Tämä voidaan toki tehdä if-lauseilla, mutta koska toinen koordinaatti suunnasta on 0 ja toinen yksi, niin

w = suunta.X * VIIVANPITUUS
h = suunta.Y * VIIVANPITUUS

tuottaisi jompaan kumpaan VIIVANPITUUS arvon ja toiseen 0. Se johon tulee 0, pitäisi saada arvoon VIIVALEVEYS. Toki tämä voitaisiin tehdä if-lauseella tyyliin:

if ( w == 0 ) w = VIIVANLEVEYS;
if ( h == 0 ) h = VIIVANLEVEYS;

Toisaalta näkyvältä if-lauseelta ja useammalta riviltä säästyään jos otetaan suurempi luivuista suunta.X * VIIVANPITUUS ja VIIVANLEVEYS, eli:

        double w = Math.Max(suunta.X * VIIVANPITUUS, VIIVANLEVEYS);
        double h = Math.Max(suunta.Y * VIIVANPITUUS, VIIVANLEVEYS);

Nyt meillä on tiedossa tarvittavan viivaa esittävän suorakaiteen leveys ja korkeus. Luodaan suorakaide normaalisti ja lisätään se peliin:

        GameObject viiva = new GameObject(w, h);
        peli.Add(viiva);

Näillä lisäyksillä ohjelma voidaan ajaa, mutta se piirtää ristin, koska kaikkien viivojen keskipiste on samassa kohdassa origossa.

Edellä on käyetty GameObject koska uusimman Jypelin fysiikkamoottorissa toisiinsa osuvia fysiikkaolioita siirretään hieman.

Seuraavaksi pitää miettiä miten viivoja siirretään niin, että viiva alkaa alkupisteestä (ensimmäisen viivan tapauksessa punaisesta pisteestä, eli origosta).

Viivan siirto

Jos viivalle ei tehdä mitään, sen keskipiste on origossa. Jos tehdään (kokeile):

    viiva.Position = piste;

sen keskipiste paikassa piste. Ajatellaanpa pystysuoraa viivaa. Jotta sen päätypiste olisi paikassa piste, pitäisi viivan keskipiste siirtää puolet viivan pituudesta ylöspäin. Eli tehdään tätä varten siirtovektori

        Vector siirto = new Vector(0, h);

ja siirretään viivan keskipiste tämän avulla:

        viiva.Position = piste + 0.5 * siirto;

Toisaalta jos kyseessä on vaakaviiva, pitäisi keskipistettä siirtää oikealle, eli siirtovektorin pitäisi silloin olla:

        Vector siirto = new Vector(w, 0);

Tämä voitaisiin taas tehdä ehtolauseella, mutta voimme käyttää hyväksi sitä, että suunnan toinen komponentti on aina 1 ja toinen 0. Eli:

        Vector siirto = new Vector(suunta.X * w, suunta.Y * h);

ja itse asiassa tämän jälkeen tuleva rivi:

        viiva.Position = piste + 0.5 * siirto;

kelpaakin nyt kummassakin tapauksessa, koska vektorin kertominen luvulla kertoo kunkin komponentin kertoimella. Eli tästä tulee nyt lisättäväksi vektoriksi joko

(0, 0.5*h)  jos suunta on y-akselin suuntaan

tai

(0.5*w, 0)  jos suunta on x-akselin suuntaan

eli juuri mitä tarvitaan. Vielä pitää saada palautettua lisätyn viivan päätepisteen koordinaatti ja se on helposti laskettavissa siirron avulla:

        return piste + siirto;

Mallivastaus

    public static Vector PiirraViiva(PhysicsGame peli, Vector piste, Vector suunta)
    {
        double w = Math.Max(suunta.X * VIIVANPITUUS, VIIVANLEVEYS);
        double h = Math.Max(suunta.Y * VIIVANPITUUS, VIIVANLEVEYS);
        GameObject viiva = new GameObject(w, h);
        Vector siirto = new Vector(suunta.X * w, suunta.Y * h);
        viiva.Position = piste + 0.5 * siirto;
        peli.Add(viiva); 
        return piste + siirto; 
    }

Mitä pitäisi vielä korjata jotta pääohjelmaa voitaisiin jatkaa riveillä:

        piste = PiirraViiva(this, piste, -pysty);
        piste = PiirraViiva(this, piste, -pysty);
        piste = PiirraViiva(this, piste, -vaaka);

Mallivastaus negatiivisille suunnille

Pitäisi estää se, ettei w ja h pääse negatiivisiksi. Tämä voitaisiin toki tehdä if-lauseella muuttujien arvojen laskemisen jälkeen:

        double w = suunta.X * VIIVANPITUUS
        double h = suunta.Y * VIIVANPITUUS
        if ( w < 0 ) w = -w;
        if ( h < 0 ) h = -h;
        if ( w == 0 ) w = VIIVANLEVEYS;
        if ( h == 0 ) h = VIIVANLEVEYS;

Toisaalta käyttämällä itseisarvoa (muistele vanha demotehtävä) voidaan etumerkki pitää aina positiivisena:

        double w = Math.Abs(suunta.X * VIIVANPITUUS)
        double h = Math.Abs(suunta.Y * VIIVANPITUUS)
        if ( w == 0 ) w = VIIVANLEVEYS;
        if ( h == 0 ) h = VIIVANLEVEYS;

Kuten edellä 0-tapauksessa if-lauseista päästään eroon maksimia käyttäen:

        double w = Math.Max(Math.Abs(suunta.X * VIIVANPITUUS), VIIVANLEVEYS);
        double h = Math.Max(Math.Abs(suunta.Y * VIIVANPITUUS), VIIVANLEVEYS);

Itseisarvo voitaisiin ottaa myös ennenkin kertolaskua, koska VIIVANPITUUS oletetaan aina positiiviseksi:

        double w = Math.Max(Math.Abs(suunta.X) * VIIVANPITUUS, VIIVANLEVEYS);
        double h = Math.Max(Math.Abs(suunta.Y) * VIIVANPITUUS, VIIVANLEVEYS);

9.3 Portaat ylös ja alas

Muutetaan seuraavaksi pääohjelmaa niin, että sillä voidaan piirtää mielivaltainen määrä portaita.

# d9t3portaatylosjaalas

Suunnittelu

Ylöspäin menevä portaiden osa saadaan piirrettyä kun entinen pääohjelman koodi siirretään aliohjelmaan ja tehdään paria

        p = PiirraViiva(this, p, pysty);
        p = PiirraViiva(this, p, vaaka);

tarvittava määrä. Alaspäin menevä osa on hieman kimurantimpi, koska jos ei haluta aloittaa ylimääräisellä tasanteella, niin yksi ylös, yksi alas pitäisi näyttää seuraavalta:

__
| |

Eli ensimmäinen alaspäin menevä porras olisi pelkkä pystyosa.

        p = PiirraViiva(peli, p, -pysty);

Seuraavat muodostuvat sitten parista:

        p = PiirraViiva(peli, p, vaaka);
        p = PiirraViiva(peli, p, -pysty);

Nyt siis ensimmäinen alaspäin menevä pitää käsitellä erikoistapauksena, ja se johtaa myös siihen, että nolla alas pitää käsitellä erikositapauksena. Toki silmukkaan voitaisiin laittaa ehto, että jos ollaan ensimmäisessä, niin vaakaosa jätetään piirtämättä. Mutta tämä rasittaisi jokaista muuta silmukan kierrosta turhalla ehdolla.

Koska ensimmäinen alas menevä porras on jo piirretty, aloitetaan silmukka yhtä pidemmältä.

Mallivastaus

        public static Vector PiirraPortaat(PhysicsGame peli, Vector piste, int ylos, int alas)
        {
            Vector vaaka = new Vector(1, 0);
            Vector pysty = new Vector(0, 1);
            Vector p = piste;
            for (int i=0; i<ylos; i++)
            {
                p = PiirraViiva(peli, p, pysty);
                p = PiirraViiva(peli, p, vaaka);
            }
            if ( alas <= 0 ) return p;
            p = PiirraViiva(peli, p, -pysty);
            for (int i=1; i<alas; i++)
            {
                p = PiirraViiva(peli, p, vaaka);
                p = PiirraViiva(peli, p, -pysty);
            }
            return p;
        }

Silmukat voisivat olla myös muodossa:

for (int i=1; i<=ylos; i++)
...
for (int i=2; i<=alas; i++)

jos ajatellaan että i numeroi monettako porrasta piirretään "kansankielellä", eli ekan portaan numero on 1.

# hyotyd9

Demojen harjoittelu 2024kesa

Demo 3

3.4 Funktioita

Tehtävä 4. Neliö

Demo 4

4.2 Merkkijonofunktio

Tehtävä 2. Onko pitkä

4.4 Char-luokka

Tehtävä 4.4 Loppuu numeroon

Demo 5

5.1 StringBuilder

Tehtävä 1. Lisää jonoon

5.2 Taulukot ilman silmukkaa

Tehtävä 2. Montako kuutosta

5.3 Lukujen tulostaminen

Tehtävä 3. Tulosta lukuja

5.4 Taulukot silmukalla

Tehtävä 4. Montako kuutosta, silmukalla

Demo 6

6 Tauno 2. Matriisin indeksit

Tehtävä Tauno 2.1

Tehtävä Tauno 2.2

Tehtävä Tauno 2.3

Tehtävä Tauno 2.4

Tehtävä Tauno 2.5

6.2 Ehto ja etumerkin vaihtaminen

Tehtävä 2a. Etumerkin vaihto

Tehtävä 2b. Etumerkin vaihto summasta

6.3 Etsiminen

Tehtävä 3. Taulukosta etsiminen

Demo 7

7.1 Vektoreita taulukossa

Tehtävä 1. Pisteet taulukossa

7.2 Arvo lukuja taulukkoon

Tehtävä 1. Pisteet taulukossa

7.3 Etsi vektoritaulukosta

Tehtävä 1. Pisteet taulukossa

7.5 Kirjainten tutkiminen

Tehtävä 5. Laske isot

7.6 Taulukon vastinalkioiden summataulukko

Tehtävä 6. Taulukkojen summa

7.6 Matriisin palauttamien

Tehtävä 6. Matriisin palauttaminen

Demo 8

8.1 Jaollisuus

Tehtävä 8. Jaollisuus

8.2 Luvun sanallinen vastike

Tehtävä 2.1 if-lause

Tehtävä 2.2 switch-case -lause

Tehtävä 2.3 Taulukolla

Demo 9

9.1 Montako samojen joukkoa

Tehtävä 1. Peräkkäisten tutkiminen

9.2 Vektorit ja viivat

Tehtävä 2: Viivan piirto ja siirtymä

9.3 Portaat ylös ja alas

Tehtävä 3: Portaat ylös ja alas