Sivulta löytyy:

Tällä sivulla käydään läpi muutamia ohjelmointiin liittyviä peruskäsitteitä, jotka toivottavasti auttavat tehtävien tekemisessä. Pyrin päivittämään osiota tarpeen mukaan.

Muuttujat

Muuttujien arvoa voidaan niiden nimen mukaisesti muuttaa ohjelman sisällä. Käytän tehtävissä suurimmaksi osin C#-ohjelmointikieltä, jossa muuttujalla on aina tietty tyyppi. Näitä tyyppejä ovat esimerkiksi:

  • int (kokonaisluku)
  • double (reaaliluku)
  • string (merkkijono)
  • char (merkki)
Tietty muuttuja esitellään aina KERRAN, jolloin muuttujalle annetaan tyyppi ja nimi. Arvo voidaan antaa, mutta se ei ole pakollista. Esimerkki: 
1
2
3
4
5
6

// Tämä on kommentti, ohjelman suorittamisessa
//ei huomioida rivejä jotka alkavat "//"
int a = 3;
string lappari = "windows";
char ekaKirjain;
ekaKirjain = "t";
Eli tyyppi ensin ja sitten nimi. Kun muuttuja on jo esitelty ja siihen halutaan sijoittaa jokin arvo, tyyppiä ei enää kirjoiteta. (esim. ekaKirjain = "t"; tuossa yllä)

Taulukot

Käsitellään tässä yksiulotteisia taulukoita. Taulukko on kokonaisuus, jossa on joukko tietyn tyyppistä sisältöä. Käytetään esimerkkinä kokonaislukutaulukkoa, joka voidaan alustaa seuraavasti: 

1
2
3

int[] taulukko_a = new int[4]; /* Alustaa taulukon, jossa on 4 paikkaa
                  kokonaisluvuille. Arvot sijoitetaan myöhemmin.
			(kommentti voidaan merkitä myös näin)*/
Taulukko voidaan alustaa myös sijoittamalla arvot heti: 
1
2

int[] taulukko_b = { 3, 4, 1, 100, 6 }; /* Nyt syntyy 5-paikkainen 
             taulukko, jossa on arvot jo valmiiksi sijoitettuna.*/

Taulukon indeksointi

Taulukon indeksointi aloitetaan ohjelmointikielissä yleensä nollasta. Eli ensimmäisen alkion indeksi on nolla, toisen yksi jne... Esim. 
1
2
3
4

        /* indeksit: 0  1  2    3  4*/
int[] taulukko_b = { 3, 4, 1, 100, 6 }; 
System.Console.WriteLine(taulukko_b[2]); /*tässä siis tulostetaan taulukon alkio
jonka indeksi on 2*/
Ja tulostus olisi: 
1

Silmukat

Silmukoiden idea yksinkertaistetusti on, että toistetaan tiettyä toimenpidettä useita kertoja. Silmukkarakenteita on muutamia erilaisia, ja käydään tässä nyt pari niistä läpi.

for-silmukka

Tähänkin on helpointa tutustua esimerkin avulla (tässä myös esimerkki c#-pääohjelman syntaksista): 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System;

public class Test
{
	public static void Main()
	{
		string[] nimet = {"Pekka", "Petra", "Kalle", "Kaisa"};

		for (int i = 0; i < nimet.Length ; i++)
                 {
                    Console.WriteLine(nimet[i]);
                 }
	}
}

Tuossa koodissa sanan for jälkeen esitellään ensin indeksimuuttuja i, jonka alkuarvo on nolla. Sitten puolipisteen jälkeen kerrotaan miten kauan silmukkaa pyöritetään. Tässä niin kauan kuin i on pienempi kuin nimet-taulukon pituus, eli neljä. Viimeiseksi sanotaan mitä jokaisen silmukan kierroksen lopussa tehdään - tässä tapauksessa kasvatetaan muuttujaa i yhdellä (i++ tarkoittaa siis, että i kasvaa yhdellä).

Muuttuja i käy siis kierroksilla läpi arvot 0, 1, 2 ja 3. Ensimmäisellä silmukan kierroksella tulostetaan siis nimet[0] eli Pekka, toisella nimet[1] eli Petra jne... Ja tulostus kokonaisuudessaan on: 

Pekka
Petra
Kalle
Kaisa

while-silmukka

while on idealtaan melko sama kuin for, mutta näyttää hiukan erilaiselta. Jossain tilanteissa while on sopivampi kuin myös joskus on saa etua kun käyttää foria. Esimerkki: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14

using System;

public class Test
{
	public static void Main()
	{
		int i = 0;
		while (i < 6)
		{
		   Console.WriteLine(i);
		   i = i + 2;
		}
	}
}
while-silmukassa siis indeksimuuttuja esitellään ennen silmukkaa, ja while-sanan jälkeen kerrotaan vain miten kauan silmukkaa pyöritetään. Myöskin indeksimuuttujan mahdollinen kasvattaminen tehdään silmukan sisällä. Tässä i kasvaa joka kierroksella kahdella. Tulostus olisi: 
0
2
4

If - else -rakenne

If-rakenteen avulla voidaan toteuttaa tietty operaatio, jos haluttu ehto on tosi. Esimerkiksi tulostetaan kokonaislukutaulukon alkio, jos se on suurempi kuin 5. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

using System;

public class Test
{
	public static void Main()
	{
		int[] taulukko_b = { 3, 4, 1, 100, 6 }; 

		for (int i = 0; i < taulukko_b.Length ; i++)
                 {
		   if ( taulukko_b[i] > 5)
		    {
		     Console.WriteLine(taulukko_b[i]);
		    }
                    
                 }
	}
}
Ylläolevassa esimerkissä käydään taulukko läpi for-silmukalla ja jokaisella kierroksella tutkitaan, onko tarkasteltava alkio suurempi kuin 5. Jos on, se tulostetaan. Tulostus olisi 
100
6
Lisätään vielä edelliseen esimerkkiin else-rakenne. Tämän rakenteen avulla voidaan kertoa, mitä tehdään jos ehtomme ei toteudu. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using System;

public class Test
{
	public static void Main()
	{
		int[] taulukko_b = { 3, 4, 1, 100, 6 }; 

		for (int i = 0; i < taulukko_b.Length ; i++)
                 {
		   if ( taulukko_b[i] > 5)
		    {
		     Console.WriteLine(taulukko_b[i]);
		    }
	           else
	           {
                       Console.WriteLine("Alkio on pienempi kuin 5.");
	           }
                 }
	}
}
Tulostus olisi: 
Alkio on pienempi kuin 5.
Alkio on pienempi kuin 5.
Alkio on pienempi kuin 5.
100
6

Aliohjelmat

Operaatiosta kannattaa tehdä aliohjelma, jos on todennäkoistä, että kyseinen operaatio halutaan suorittaa uudelleen eri arvoille. Tällainen tilanne voisi olla esim. kolmion pinta-alan laskeminen. Oletetaan, että meillä on usein tilanne, jossa tiedämme suorakulmion kannan ja korkeuden ja haluamme ulkoistaa pinta-alan laskemisen muualle. Tehdään siitä aliohjelma: 

1
2
3
4
5
6
7
8
9
10

    /// <summary>
    /// Aliohjelma laskee suorakulmion pinta-alan
    /// </summary>
    /// <param name="kanta">Suorakulmion kanta</param>
    /// <param name="korkeus">Suorakulmion korkeus</param>
    /// <returns>Suorakulmion pinta-ala</returns>
    public static double SuorakulmionPintaAla(double kanta, double korkeus)
    {
        return kanta*korkeus;
    }
Aliohjelman yläpuolella on kommentit, jotka on hyvä muistaa kirjoittaa koodin luettavuuden säilyttämiseksi. Kommenteissa kerrotaan ensin, mitä aliohjelma tekee. Sitten esitellään aliohjelman parametrit, eli tiedot joita se tarvitsee toimiakseen. Lopuksi vielä kerrotaan, mitä tietoa aliohjelma palauttaa. Tässä tapauksessa se palauttaa pinta-alan. Jos aliohjelma palauttaa jotain tietoa sitä kutsutaan itseasiassa funktioksi. Katsotaan kohta millainen olisi pelkkä aliohjelma.

Aliohjelman esittelyrivillä "public" ja "static" sanoista ei tarvitse vielä kauheasti välittää, mutta kolmas sana "double" määräytyy sen mukaan, minkä tyyppistä tietoa aliohjelma palauttaa. Tässä tapauksessa se palauttaa pinta-alan, joka on reaaliluku eli double. Seuraavaksi tulee aliohjelman nimi ja sulkuihin parametrit. Aliohjelmaa esiteltäessä täytyy sulkuihin kirjoittaa myös parametrien tyypit. Aliohjelman sisältö on tässä tapauksessa melko lyhyt, siinä kirjoitetaan vain mitä aliohjelma palauttaa, eli kanta*korkeus.

Katsotaan sitten miten tuota aliohjelmaa käytetään pääohjelmasta: (Tulostuksen voit kokeilla itse. Kopioi koodi, mene sivulle https://ideone.com/, vaihda kieleksi C#, liitä koodi ja paina "run".) 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    using System;

    public class Test
    {
    	public static void Main()
    	{
             double kanta_a = 5.4;
             double korkeus_a = 2.3;
             
             double kanta_b = 3.3;
             double korkeus_b = 4.0;
             
             double ala_a = SuorakulmionPintaAla(kanta_a, korkeus_a);
             double ala_b = SuorakulmionPintaAla(kanta_b, korkeus_b);
             
             Console.WriteLine(ala_a);
             Console.WriteLine(ala_b);
    	}
    
	
        /// <summary>
        /// Aliohjelma laskee suorakulmion pinta-alan
        /// </summary>
        /// <param name="kanta">Suorakulmion kanta</param>
        /// <param name="korkeus">Suorakulmion korkeus</param>
        /// <returns>Suorakulmion pinta-ala</returns>
        public static double SuorakulmionPintaAla(double kanta, double korkeus)
        {
            return kanta*korkeus;
        }
	
    }
Pääohjelmassa siis esitellään kaksi eri pinta-alaa, joihin sijoitetaan arvot kutsumalla tekemäämme aliohjelmaa (funktiota). Kutsuun tulee aliohjelman nimi ja sulkuihin laitetaan ne arvot, joilla aliohjelman halutaan laskelmansa tekevän. Näin tämän aliohjelman(funktion) palauttama arvo siis sijoitetaan pinta-ala-muuttujiin.

Katsotaan myös esimerkki puhtaasta aliohjelmasta (eli ei funktiosta!), joka ei siis palauta mitään. Tehdään aliohjelma, joka tulosta sille annetun sanan aina isoilla kirjaimilla: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    using System;

    public class Test
    {
    	public static void Main()
    	{
            string nimi = "pekka";
            
            Tulosta(nimi);
            Tulosta("PiRjo");
      
    	}
    
	
        /// <summary>
        /// Tulostaa isona
        /// </summary>
        /// <param name="sana">Tulostettava sana</param>
        /// <returns></returns>
        public static void Tulosta(string sana)
        {
            Console.WriteLine(sana.ToUpper());
        }
	
    }
Kun on kyse aliohjelmasta (joka siis ei palauta mitään!!), esittelyrivin kolmas sana on "void". Tässä tapauksessa myöskään "return" -sanaa ei tarvitse olla ohjelman sisällä. Tässä myös esimerkki metodista ToUpper(), joka ottaa string-muuttujasta kopion ja muuttaa kaikki kirjaimet isoiksi. Tässä vaiheessa ei tarvitse tietää syvemmin, mikä on metodi. Se olisi hyvä tietää, että on olemassa tällaisia metodeita, joilla saadaan tehtyä esim. kirjainkoon muutoksia tai erilaisia vertailuja.