Ohjelmointi 1, tentti 13.6.2014. Tentaattori Antti-Jussi Lakanen.

Arviointiraportti

Yleistä
=======

[Tentti](http://users.jyu.fi/~anlakane/ohjelmointi1/tentit/2014-06-13-tentti3.pdf) (<http://users.jyu.fi/~anlakane/ohjelmointi1/tentit/2014-06-13-tentti3.pdf>).

Omasta tehtäväpaperista saa kopion saa Antti-Jussilta, huone C414.2. Jos en
ole paikalla, laita sähköpostia tai soita 0500 603111. Papereihin on merkitty
virheet, jotka voin käydä kanssasi läpi.

Tentti oli tämän kevään toinen uusintatentti, joten jos ei tällä kertaa
onnistanut, niin sitten syksyllä uudestaan.

# Tehtävä 1

## Malliratkaisu

```c
/// <summary>
/// Antaa pisimmän laskevan osajonon pituuden.
/// </summary>
/// <param name="luvut">Luvut</param>
/// <returns>Pisimmän laskevan osajonon pituus.</returns>
/// <example>
/// <pre name="test">
///  int[] luvut = { 5, 3, 4, 4, 2, 0, 1, 2, 3, 3, 2 };
///  LaskevaJono.PisinLaskevaJono(luvut) === 4;
///  int[] luvut2 = { 5, 4, 3, 2, 1 };
///  LaskevaJono.PisinLaskevaJono(luvut2) === 5;
///  int[] luvut3 = { 1, 2, 3 };
///  LaskevaJono.PisinLaskevaJono(luvut3) === 1;
///  int[] luvut4 = { 3 };
///  LaskevaJono.PisinLaskevaJono(luvut4) === 1;
///  int[] luvut5 = { };
///  LaskevaJono.PisinLaskevaJono(luvut5) === 0;
///  int[] luvut6 = { 3, 3, 3 };
///  LaskevaJono.PisinLaskevaJono(luvut6) === 3;
/// </pre>
/// </example>
public static int PisinLaskevaJono(int[] luvut)
{
    if (luvut.Length == 0) return 0;
    int pisin = 1;

    int pituusNyt = 1;
    for (int i = 1; i < luvut.Length; i++)
    {
        if (luvut[i] <= luvut[i - 1]) pituusNyt++;
        else pituusNyt = 1;
        if (pituusNyt > pisin) pisin = pituusNyt;
    }
    return pisin;
}
```
# Tehtävä 2

## Malliratkaisu

A-kohdassa tulostus:

```
1
0,75
1
0
```

Laskutoimituksen (operaation) lopputulos riippuu operandien tyypeistä.
Esimerkiksi kaksi `int`-lukua jaettuna toisillaan tuottaa `int`-luvun, joten
`5/4 = 1`.

B-kohdassa lopputuloksena on, että `nimi`-muuttujan arvo on `Aku Ankka` ja
`nimi2`-muuttujan arvo on `Roope Sorsa`. Oleellista on, että
`String.Replace`-funktio palauttaa uuden `String`-olion, joten alkuperäinen ei
muutu mihinkään.

```
+--------------------------------------------+-------------+---------------+
|                 Koodirivi                  |     nimi    |     nimi2     |
+--------------------------------------------+-------------+---------------+
| public...                                  |             |               |
| {                                          |             |               |
| string nimi = "";                          | ""          |               |
| nimi += "Aku";                             | "Aku"       |               |
| nimi += " ";                               | "Aku "      |               |
| nimi += "Ankka";                           | "Aku Ankka" |               |
| nimi.Replace("Ankka", "Sorsa");            | "Aku Ankka" |               |
| StringBuilder nimi2 = new StringBuilder(); | "Aku Ankka" | ""            |
| nimi2.Append("Roope");                     | "Aku Ankka" | "Roope"       |
| nimi2.Append(" ");                         | "Aku Ankka" | "Roope "      |
| nimi2.Append("Ankka");                     | "Aku Ankka" | "Roope Ankka" |
| nimi2.Replace("Ankka", "Sorsa");           | "Aku Ankka" | "Roope Sorsa" |
| }                                          | "Aku Ankka" | "Roope Sorsa" |
+--------------------------------------------+-------------+---------------+

```

## Pisteytys ja virheet

Tehtävän arvostelu oli tiukahko, vastausten piti olla oikein, muuten ei
pisteitä tullut. A-kohdassa toki perustelu oli tärkeä. A-kohta oli helppo ja
moni sai täydet pisteet siitä. B-kohdassa monikaan ei muistanut, että
`String.Replace` luo uuden olion, eikä koske vanhaan. Yleisin pistemäärä tästä
oli 4.5 pistettä.

# Tehtävä 3

## Malliratkaisu

Kohta 1. Operaattori `==` vertailee kahta arvoa ja palauttaa totuusarvon. 
    Operaattori `=` tekee sijoituksen. Vrt.  
```c 
if (i == 0) { /* Jos i:n arvo on nolla niin tehdään jotain... */ }
int i = 5; // Sijoitus`
```
Kohta 2. `return`-lause on C#-kielen avainsana. `return`-lausetta käytetään
    aliohjelmasta poistumiseen (`void`-aliohjelma) tai palauttamaan arvo
    funktioaliohjelmasta.

Kohta 3. `do-while`-silmukassa `do`-osa suoritetaan vähintään yhden kerran,
    kun `while`-silmukassa runko-osaa ei suoriteta välttämättä yhtään kertaa.

Kohta 4. Kun `int a = 3; int b = 5;` niin lausekkeen `b % a < b - a` arvo on `false`. Perustelu:
```c
b % a == 2,
b - a == 2,
2 < 2 == false.
```
 
Kohta 5. `28 / 6 == 4`ja `28 % 6 == 4`.

Kohta 6. Yhteistä on, että sekä listaan että taulukkoon voidaan laittaa useita
samantyyppisiä alkioita. Lisäksi yhteistä on, esimerkiksi, että molempia
voidaan käydä läpi indeksin avulla. Erona on, että listaan voi lisätä ja siitä
voi poistaa alkioita, eli sen koko voi muuttua ohjelman suorituksen aikana
(siitä nimi "dynaaminen"). Tämä ei onnistu taulukoille.

# Tehtävä 4

## Malliratkaisu

A-kohdassa piti laskea `double`-taulukon keskiarvo.

```c
/// <summary>
/// Antaa double-taulukon lukujen keskiarvon.
/// Jos ei yhtään alkiota, palauttaa 0.0.
/// </summary>
/// <param name="luvut">Tukku liukulukuja.</param>
/// <returns>Lukujen keskiarvo.</returns>
public static double Keskiarvo(double[] luvut)
{
    if (luvut.Length == 0) return 0.0;
    double summa = 0.0;
    for (int i = 0; i < luvut.Length; i++)
    {
        summa += luvut[i];
    }
    return summa / luvut.Length;
}
```

B-kohdassa käännettiin merkkijono.

```c
/// <summary>
/// Palauttaa käännetyn merkkijonon.
/// </summary>
/// <param name="jono">Käännettävä jono.</param>
/// <returns>Käännetty jono.</returns>
/// <example>
/// <pre name="test">
///  KeskiarvoJaKaantaminen.Kaanna("joo") === "ooj";
///  KeskiarvoJaKaantaminen.Kaanna("joopa joo") === "ooj apooj";
/// </pre>
/// </example>
public static String Kaanna(String jono)
{
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < jono.Length; i++)
    {
        sb.Append(jono[jono.Length - i - 1]);
    }
    return sb.ToString();
}

```

## Yleiset huomiot

Tehtävässä pyydettiin tekemään *funktio*, joten luokan ja pääohjelman
kirjoittaminen ei ollut tarpeellista eikä niitä arvosteltu. 

# Tehtävä 5

## Malliratkaisu

```c
using System;
using System.Text;
using System.Linq;
using System.Collections.Generic;

/// @author Antti-Jussi Lakanen
/// @version 13.6.2014
/// 
/// <summary>
/// Ohjelmassa kysytaan kayttajalta luku, ja tekee sen mukaan
/// kokonaisarvoisia satunnaislukuja valille [1, 99999].
/// Sitten lasketaan kunkin numeron 1-9 prosentuaalinen esiintymisosuus
/// luvun ensimmaisena numerona.
/// </summary>
public class Satunnaisluvut
{
    /// <summary>
    /// Pyydetaan syote ja luodaan satunnaisluvut. Tulostetaan lopuksi osuudet.
    /// </summary>
    public static void Main()
    {
        Console.Write("Montako lukua tehdään? ");
        int montakoLukua = int.Parse(Console.ReadLine());
        int[] jakauma = new int[9];
        Random r = new Random();
        for (int i = 0; i < montakoLukua; i++)
        {
            int luku = r.Next(1, 100000);
            int ekaLuku = AnnaEka(luku);
            jakauma[ekaLuku - 1]++;
        }

        Console.WriteLine(
            "Arvottiin " + montakoLukua + " lukua " +
            "väliltä 1-99999, ja sain seuraavat prosenttiosuudet arvottujen " +
            "lukujen ensimmäisistä numeroista: ");
        for (int i = 0; i < jakauma.Length; i++)
        {
            Console.WriteLine(
              i + 1 + ": " + 1.0 * jakauma[i] / montakoLukua * 100 + "%");
        }
    }

    /// <summary>
    /// Antaa kokonaisluvun ensimmäisen numeron.
    /// </summary>
    /// <param name="luku">Kokonaisluku</param>
    /// <returns>Ensimmäinen numero</returns>
    /// <example>
    /// <pre name="test">
    ///  Satunnaisluvut.AnnaEka(42) === 4;
    ///  Satunnaisluvut.AnnaEka(1) === 1;
    ///  Satunnaisluvut.AnnaEka(0) === 0;
    ///  Satunnaisluvut.AnnaEka(12345) === 1;
    ///  Satunnaisluvut.AnnaEka(-12345) === 1;
    /// </pre>
    /// </example>
    public static int AnnaEka(int luku)
    {
        int i = Math.Abs(luku);
        while (i >= 10) { i /= 10; }
        return i;
    }
}
```