/*Tehtävä 16 (Jukka Stenlund 2006 Jaakko Nurron tehtävään 11 kirjoittaman 
joulukuusikoodin pohjalta)*/

import java.util.Scanner;

public class Joulukuusipaja {
    private static void tulostaJoulukuusi(int korkeus) {
        /* Tulostetaan joulukuusen tähtirivit */
        for (int rivi = 1; rivi <= korkeus; rivi++) {
            /* Rivin alkuun tulee välilyöntejä */
            for (int tyhjä = korkeus - rivi; tyhjä > 0; tyhjä--)
                System.out.print(" ");
            /* Välilyöntien jälkeen tulee tulostettavan rivin numero*2 -1 tähteä */
            for (int tähtiä = rivi * 2 - 1; tähtiä > 0; tähtiä--)
                System.out.print("*");
            System.out.println(); // kun koko rivi on tulostettu, vaihdetaan
                                    // riviä
        }
    }

    public static void main(String[] args) {
        Scanner lukija = new Scanner(System.in); // luodaan Scanner-olio,
                                                    // jolta voi pyytää sitten
                                                    // kokonaislukuja
        // Korkeutta kysellään käyttäjältä, kunnes tämä syöttää ei-negatiivisen
        // kokonaisluvun.
        int korkeus;
        boolean kelpoluku;
        int jatkovastaus = 0;
        boolean jatkovastausOK = false;
        do {
            do {
                do {
                    System.out
                            .println("Minkä korkuisen (positiivinen "+
                                    "kokonaisluku) joulukuusen haluat?");
                    kelpoluku = lukija.hasNextInt();
                    if (!kelpoluku) { // jos ei ollut kelvollinen
                                        // kokonaisluku...
                        lukija.next();// ...luetaan roska pois
                        System.out.println("Kirjoita korkeus pelkillä "+
                                "numeromerkeillä.");
                    }
                } while (!kelpoluku);
                korkeus = lukija.nextInt(); // Nyt pitäisi onnistua.

                if (korkeus < 0)
                    System.out.println("Korkeuden pitäisi olla positiivinen"+
                            " kokonaisluku, nollakin käy.");

            } while (korkeus < 0);

            tulostaJoulukuusi(korkeus);

            do {
                jatkovastausOK = true;
                System.out.println("Haluatko lisää kuusia (1=kyllä, 2=en)?");
                if (!lukija.hasNextInt()) {
                    lukija.next();// luetaan roska pois;
                    jatkovastausOK = false;
                } else { // saatiin kokonaisluku, katsotaan vielä, onko se 1
                            // tai 2
                    jatkovastaus = lukija.nextInt();// nyt pitäisi onnistua
                    if (jatkovastaus != 1 && jatkovastaus != 2)
                        jatkovastausOK = false;
                }

                if (!jatkovastausOK) {
                    System.out.println("Jos haluat jatkaa, vastaa 1, muuten "+
                            "vastaa 2.");
                }

            } while (!jatkovastausOK);// kysytään uudelleen, kunnes saadaan
                                        // kunnon vastaus

        } while (jatkovastaus == 1);

        System.out.println("Kiitoksia palvelumme käyttämisestä!");

    }

}

--------------------------------------------------------------------

/**
 * Introduction to Programming, autumn 2006
 * Example solution for exercise 17
 * Samuli Kaipiainen
 */
import java.util.Scanner;

public class RaiseToPower {

    public static Scanner reader = new Scanner(System.in); // Added by Jukka
                                                            // Stenlund 2006

    /**
     * Our Raise-To-Power Service.
     */
    public static void main(String[] args) {
        double base;
        int power;

        System.out
                .println("Hello, I'm your Raise-To-Power service;\n"
                        + "enter base (decimal) followed by power (integer), "+
                        "they can be on a same line.\n"
                        + "Entering \"0 0\" exits.\n");

        do {
            System.out.print("Give base and power: ");
            base = reader.nextDouble();
            power = reader.nextInt();

            System.out.println(base + "^" + power + " = "
                    + raiseToPower(base, power) + "\n");

        } while (base != 0 || power != 0);
    }

    /**
     * Computes base raised to power; 0^0 is agreed to be 1 here.
     */
    private static double raiseToPower(double base, int power) {
        double ans = 1;

        for (int n = 0; n < abs(power); n++)
            ans *= base;

        if (power < 0)
            ans = 1 / ans;

        return ans;
    }

    /**
     * Returns an absolute number of an int.
     * 
     * Yes, you're allowed to create methods not specified in the exercise :)
     */
    private static int abs(int n) {
        return n > 0 ? n : -n;
    }
}

--------------------------------------------------------------------

/**
 * Ohjelmoinnin perusteet, syksy 2006, tehtävä 18.
 * 
 * HUOM! Tässä on esitetty vain yksi näkemys radion mallintamiseksi. Tässä
 * radiossa on painettava on/off-kytkin ja käännettävät säätimet kanavalle ja
 * volumelle. Säätimiä voidaan käännellä vaikka radio olisikin poissa päältä.
 * 
 * Esimerkkiratkaisun laati Jaakko Nenonen. Testipääohjelman kommenttia muokkasi
 * Jukka Stenlund.
 */
public class Radio {

    /*
     * Määritellään vakioita ylläpidettävyyden nimissä. Nämä ovat muuttujia,
     * joiden arvoa ei voi muuttaa sen jälkeen kun ne ovat kerran saaneet 
     * arvon.
     */
    private static final int VOLMIN = 0;

    private static final int VOLMAX = 9;

    private static final double KANMIN = 2300.0;

    private static final double KANMAX = 26100.0;

    /* luokan yksityiset kentät */
    private boolean päällä;

    private int volume;

    private double kanava;

    /**
     * ------------konstruktori------------ 
     * Alkuarvot on valittu
     * "mielivaltaisesti": uusi radio on pois päältä ja sen säätimet
     * minimiasennossa.
     */
    public Radio() {
        päällä = false;
        volume = VOLMIN;
        kanava = KANMIN;
    }

    /**
     * Metodi vaihdaOnOff toimii virtanappulana eli vaihtaa päällä- muuttujan
     * arvon vastakkaiseksi. Toisin sanoen, jos radio on päällä tätä metodia
     * kutsuttaessa, se laitetaan pois päältä. Jos taas se oli poissa päältä, 
     * se laitetaan päälle.
     */
    public void vaihdaOnOff() {
        if (päällä == true)
            päällä = false;
        else
            päällä = true;
        /*
         * edellisen voi kirjoittaa lyhyemminkin yhdellä lauseella: 
         * päällä != päällä;
         */
    }

    /**
     * Metodi säädäVolumea säätää volumea parametrina annetun luvun verran
     * (positiiviset parametrit lisäävät volumea, negatiiviset vähentävät). Jos
     * volume menee pois säädetyltä alueelta, se asetetaan kyseisen suuntaiseksi
     * ääripääksi.
     */
    public void säädäVolumea(int muutos) {
        // Huom! Ei varauduta ali- tai ylivuotoihin!
        volume += muutos;
        if (volume > VOLMAX) { // volat kaakossa
            volume = VOLMAX;
        } else if (volume < VOLMIN) {
            volume = VOLMIN;
        }
    }

    /**
     * Metodi vaihdaKanavaa säätää kanavaa parametrina annetun luvun verran
     * (positiiviset parametrit lisäävät, negatiiviset vähentävät). Jos kanava
     * menee pois säädetyltä alueelta, se asetetaan kyseisen suuntaiseksi
     * ääripääksi.
     */
    public void vaihdaKanavaa(double muutos) {
        kanava += muutos;
        if (kanava < KANMIN) {
            kanava = KANMIN;
        } else if (kanava > KANMAX) {
            kanava = KANMAX;
        }
    }

    /**
     * Seuraavat kolme metodia mahdollistavat radion nappuloiden asentojen
     * "katselemisen" yksi kerrallaan. Näitäkin voitaisiin jossakin
     * radiosovelluksessa tarvita.
     */
    public boolean onkoPäällä() {
        return päällä;
    }

    public int annaVolume() {
        return volume;
    }

    public double annaKanava() {
        return kanava;
    }

    /**
     * toString-metodi palauttaa radio-olion tilan String-merkkijonona
     */
    public String toString() {
        return "radio-olio:  päällä=" + päällä + ", kanava=" + kanava
                + ", volume=" + volume;
    }

    /**
     * Testipääohjelma. Testataan kaikki metodit pyytämällä sekä
     * toteutuskelpoisia että toteutuskelvottomia muutoksia 
     * äänenvoimakkuuden ja kanavan arvoihin.
     */
    public static void main(String[] args) {
        Radio testi = new Radio();
        System.out.println(testi);
        testi.säädäVolumea(8);
        System.out.println(testi);
        testi.säädäVolumea(-4);
        System.out.println(testi);
        testi.säädäVolumea(20);
        System.out.println(testi);
        testi.säädäVolumea(-30);
        System.out.println(testi);
        testi.vaihdaKanavaa(10000);
        System.out.println(testi);
        testi.vaihdaKanavaa(-2549);
        System.out.println(testi);
        testi.vaihdaKanavaa(40000);
        System.out.println(testi);
        testi.vaihdaKanavaa(-30000);
        testi.vaihdaOnOff();
        System.out.println(testi);
        testi.vaihdaOnOff();
        System.out.println(testi);
    }
}

--------------------------------------------------------------------

/**
 * Ohjelmoinnin perusteet, syksy 2006, Tehtävä 19 (osa).
 * 
 * Ensimmäinen tapa tehdä sekunttilaskuri, jossa luokan ainoana kenttänä on
 * sekunnit. Sekunttien määrästä voidaan laskea jakolaskun ja jakojäännöksen
 * avulla tuntien ja minuuttien määrä. Tässä ratkaisussa sekunttien kasvataminen
 * on tehokas operaatio mutta laskurin tilan kuvaaminen toStringinä hidas
 * laskutoimitusten vuoksi.
 * 
 * Ratkaisun laati Jaakko Nenonen.
 * 
 */
public class SekuntiLaskuri {

    // Vakioita eli muuttumattomina pysyviä arvoja.
    // Nimettyjen vakioiden nimet on tapana kirjoittaa isoilla kirjaimilla.
    private int SEKUNTEJA_MINUUTISSA = 60;

    private int SEKUNTEJA_TUNNISSA = 60 * SEKUNTEJA_MINUUTISSA; // 3600

    private int SEKUNTEJA_VUOROKAUDESSA = 24 * SEKUNTEJA_TUNNISSA; // 86400

    // Aikaa kuvataan olion sisällä sekuntien yhteismääränä (0...86399).
    private int sekunnit;

    /** Luo SekuntiLaskuri-tyyppisen olion. */

    public SekuntiLaskuri() {
        this.sekunnit = 0;
    }

    /**
     * Lisää sekuntien määrää yhdellä. Jos vuorokausi tulee täyteen, laskuri
     * aloittaa alusta.
     */
    public void lisaaSekunti() {
        // Jakojäännösjako hoitaa laskurin nollaamisen vuorokauden täyttyessä.
        // Muulloin sillä ei ole vaikutusta.
        this.sekunnit = (this.sekunnit + 1) % SEKUNTEJA_VUOROKAUDESSA;
    }

    /** Palauttaa tuntien määrän (0...23). */
    public int annaTunnit() {
        // Kokonaislukujaon ansiosta palautetaan vain täydet tunnit.
        return this.sekunnit / SEKUNTEJA_TUNNISSA;
    }

    /** Palauttaa minuuttien määrän (0...59). */
    public int annaMinuutit() {
        // Ensin jakojäännösjaolla poistetaan kokonaisten tuntien "käyttämät"
        // sekunnit. Sitten kokonaislukujaolla palautetaan lopuista sekunneista
        // muodostuvat täydet minuutit.
        return (this.sekunnit % SEKUNTEJA_TUNNISSA) / SEKUNTEJA_MINUUTISSA;
    }

    /** Palauttaa sekuntien määrän (0...59). */
    public int annaSekunnit() {
        // Kun poistetaan jakojäännösjaolla täysien tuntien ja minuuttien
        // "käyttämät" sekunnit, jäljelle jäävät "loput" sekunnit.
        return this.sekunnit % SEKUNTEJA_MINUUTISSA;
    }

    /**
     * Palauttaa Sekuntilaskuri-tyyppisen olion tilaa kuvaavan String-tyyppisen
     * olion, esimerkiksi "12:35:8".
     */
    public String toString() {
        return this.annaTunnit() + ":" + this.annaMinuutit() + ":"
                + this.annaSekunnit();
    }

}
/**
 * Ohjelmoinnin perusteet, syksy 2006, Tehtävä 19 (osa).
 * 
 * Toinen, ehkä perinteisempi tapa tehdä sekunttilaskuri, joka käyttää
 * sisäisesti kolmea kenttää : tunnit, minuutit ja sekunnit.
 * 
 * Ratkaisun laati Jaakko Nenonen
 * 
 */
public class SekuntiLaskuri2 {

    // Vakioita eli muuttumattomina pysyviä arvoja.
    // Nimettyjen vakioiden nimet on tapana kirjoittaa isoilla kirjaimilla.

    private int MAX_SEKUNNIT = 59;

    private int MAX_MINUUTIT = 59;

    private int MAX_TUNNIT = 23;

    // Aikaa kuvataan olion sisällä tunteina (0...23), minuutteina (0...59) ja

    // sekunteina (0...59).

    private int tunnit;

    private int minuutit;

    private int sekunnit;

    /** Luo SekuntiLaskuri2-tyyppisen olion. */
    public SekuntiLaskuri2() {
        this.tunnit = 0;
        this.minuutit = 0;
        this.sekunnit = 0;
    }

    /**
     * Lisää sekuntien määrää yhdellä. Jos vuorokausi tulee täyteen, laskuri
     * aloittaa alusta.
     */
    public void lisaaSekunti() {
        if (this.sekunnit < MAX_SEKUNNIT)
            this.sekunnit++;

        else {
            this.sekunnit = 0;
            if (this.minuutit < MAX_MINUUTIT)
                this.minuutit++;
            else {
                this.minuutit = 0;
                if (this.tunnit < MAX_TUNNIT)
                    this.tunnit++;
                else
                    this.tunnit = 0;
            }
        }
    }

    /** Palauttaa tuntien määrän (0...23). */
    public int annaTunnit() {
        return this.tunnit;
    }

    /** Palauttaa minuuttien määrän (0...59). */
    public int annaMinuutit() {
        return this.minuutit;
    }

    /** Palauttaa sekuntien määrän (0...59). */
    public int annaSekunnit() {
        return this.sekunnit;
    }

    /**
     * Palauttaa Sekuntilaskuri-tyyppisen olion tilaa kuvaavan String-tyyppisen
     * olion, esimerkiksi "12:35:8".
     */
    public String toString() {
        return this.annaTunnit() + ":" + this.annaMinuutit() + ":"
                + this.annaSekunnit();
    }

}

/**
 * Ohjelmoinnin perusteet, syksy 2006, Tehtävä 19 (osa).
 */
public class SekuntiLaskuriTestaaja {
    /*
     * Luo SekuntiLaskuri-tyyppisen olion ja tulostaa sen tilan vähän yli
     * vuorokauden ajalta.
     * 
     * Testin laati Jaakko Nenonen.
     * 
     */
    public static void main(String[] args) {
        SekuntiLaskuri laskuri = new SekuntiLaskuri();

        for (int i = 0; i < 24 * 60 * 60 + 10; i++) {
            System.out.println(laskuri.toString());
            laskuri.lisaaSekunti();
        }
    }

}

/**
 * Ohjelmoinnin perusteet, syksy 2006, Tehtävä 19 (osa).
 */
public class SekuntiLaskuri2Testaaja {
    /*
     * Luo SekuntiLaskuri-tyyppisen olion ja tulostaa sen tilan vähän yli
     * vuorokauden ajalta.
     * 
     * Testin laati Jaakko Nenonen.
     * 
     */
    public static void main(String[] args) {
        SekuntiLaskuri2 laskuri = new SekuntiLaskuri2();

        for (int i = 0; i < 24 * 60 * 60 + 10; i++) {
            System.out.println(laskuri.toString());
            laskuri.lisaaSekunti();
        }
    }

}

--------------------------------------------------------------------

import java.util.Scanner;

/**
 * Säilyttää mittaussarjan minimi- ja maksimilämpötilan. Olio on aluksi
 * alkutilassa. Alkutilassa ollessaan olio palauttaa miniminä ja maksimina aina
 * lämpötilan 0.0. Erillisellä onAlkutilassa()-metodilla voidaan selvittää, onko
 * mittauksia jo kirjattu. Olio poistuu alkutilasta, kun jokin todellinen
 * lämpötila kirjataan. Olion voi halutessaan palauttaa alkutilaan.
 * 
 * Ratkaisun laati Jaakko Nenonen. Jukka Stenlund muokkasi luokkakohtaista
 * kommenttia, korjasi kirjoitusvirheen import-käskystä sekä muokkasi
 * toString-metodia ja testipääohjelman tulostusta.
 * 
 */
public class MinMax {

    private double minimi;

    private double maksimi;

    private boolean alkutilassa;

    /** Luo uuden MinMax-tyyppisen olion. Olio on alkutilassa. */
    public MinMax() {
        this.asetaAlkutilaan();
    }

    /** Asettaa olion alkutilaan. */

    public void asetaAlkutilaan() {
        this.minimi = 0.0;
        this.maksimi = 0.0;
        this.alkutilassa = true;
    }

    /**
     * Kirjaa lämpötilan. Jos olio on alkutilassa, lämpötila asetetaan sekä
     * minimiksi että maksimiksi ja alkutilasta poistutaan. Jos olio ei ole
     * alkutilassa, lämpötila asetetaan minimiksi jos se on pienempi kuin
     * tähänastinen minimi, ja maksimiksi jos se on suurempi kuin tähänastinen
     * maksimi.
     */
    public void kirjaaLämpötila(double lämpö) {
        if (this.alkutilassa) {
            this.minimi = lämpö;
            this.maksimi = lämpö;
            this.alkutilassa = false;
        }

        else if (lämpö < this.minimi)
            this.minimi = lämpö;

        else if (lämpö > this.maksimi)
            this.maksimi = lämpö;
    }

    /** Palauttaa true, jos olio on alkutilassa, muuten palauttaa false. */
    public boolean onAlkutilassa() {
        return this.alkutilassa;
    }

    /**
     * Palauttaa 0.0, jos olio on alkutilassa, tai pienimmän kirjatun
     * lämpötilan, jos olio ei ole alkutilassa. (Huomaa, että pienin kirjattu
     * lämpötila voi olla myös 0.0.)
     */
    public double mikäOnMinimi() {
        return this.minimi;
    }

    /**
     * Palauttaa 0.0, jos olio on alkutilassa, tai suurimman kirjatun
     * lämpötilan, jos olio ei ole alkutilassa. (Huomaa, että suurin kirjattu
     * lämpötila voi olla myös 0.0.)
     */
    public double mikäOnMaksimi() {
        return this.maksimi;
    }

    public String toString() {
        String merkkijonoesitys;
        if (this.onAlkutilassa())
            merkkijonoesitys = "Ei kirjattuja mittauksia";
        else
            merkkijonoesitys = "minimi=" + this.mikäOnMinimi() + ", maksimi="
                    + this.mikäOnMaksimi();
        return merkkijonoesitys;
    }

    /** Esittelee kahden MinMax-tyyppisen olion käyttämistä. */
    public static void main(String[] args) {

        Scanner lukija = new Scanner(System.in);
        String komento;
        MinMax turku = new MinMax();
        MinMax ivalo = new MinMax();

        do {

            System.out.println();
            System.out.println("Lämpötilat Turussa: " + turku.toString());
            System.out.println("Lämpötilat Ivalossa: " + ivalo.toString());
            System.out.println();

            System.out.println("t = kirjataan Turun lämpötila\n"
                    + "i = kirjataan Ivalon lämpötila\n"
                    + "muut = poistutaan ohjelmasta\n");

            System.out.print("Valintasi: ");

            komento = lukija.next();

            if (komento.equals("t") || komento.equals("i")) {
                System.out.print("Lämpötila: ");
                double lämpötila = lukija.nextDouble();
                if (komento.equals("t"))
                    turku.kirjaaLämpötila(lämpötila);
                else
                    ivalo.kirjaaLämpötila(lämpötila);

            }

        } while (komento.equals("t") || komento.equals("i"));

    }

}