Programmeerimiskeeled 2018/19 sügis

Scala teine praktikum

Näiteülesanded

Uurida mutable.Buffer signatuuri ja kirjutada järgnevasse programmi meetod lisaArvud(a: Int, b: Int), mis lisab puhvrisse xs arvud a-st kuni b-ni (a ja b kaasa arvatud).

object H1 {
  val xs = mutable.Buffer[Int]()

  def main(args: Array[String]): Unit = {
    for (x <- 1 to 20)
      xs += x

    for (x <- xs)
      printf("%d\n", x)
  }
}

Lisada eelmisesse programmi meetod summa(), mis tühjendab puhvri ning tagastab puhvris olnud arvude summa.

Kirjutada meeotd summa(xs: Seq[Int]): Int, mis tagastab järjendi summa. Lisaks kirjuta summa variant, mis võtab suvalise arvu Int argumente ja samuti tagastab nende summa.

object H3 {
  def summa(xs: Seq[Int]): Int = ???
  def summa2(x: Int*): Int = ???

  def main(args: Array[String]): Unit = {
    //printf("Summa on %d", summa(Seq(1,2,3,4,5,6)))
    //printf("Summa on %d", summa2(1,2,3,4,5,6))
  }
}

Kirjuta meetod tryki, mis trükib välja palgatabeli formaadis "<nimi>: <palk>" nii, et iga kirje tuleb eraldi reale.

object H4 {
  def main(args: Array[String]): Unit = {
    val palgad = Map("Jüri" -> 140, "Peeter" -> 30, "Jaana" -> 90,
      "Mirjam" -> 180, "Paul" -> 70)
    //tryki(palgad)
  }
}

Harjutusülesanded

Ülesanne 1

Kirjutada meetod poord, mis võtab argumendiks täisarvud a ja m ja tagastab a pöördelemendi mooduli m järgi, kui see eksisteerib, ja –1 vastasel korral. Arvu a pöördelemendiks mooduli m järgi nimetatakse täisarvu b, mille korral korrutis ab annab m-ga jagades jäägi 1. Võib eeldada, et argumendid a ja m on positiivsed, ning kasutada naiivset tsükliga algoritmi, mis tugineb faktile, et kui pöördelement leidub, siis leidub pöördelement moodulist väiksemate naturaalarvude seas.

object Programm1 {
  def poord(a: Int, m: Int): Int = ???


  def main(args: Array[String]): Unit = {
    printf("poord(%d,%d) = %d\n",3,4, poord(3,4))
  }
}

Ülesanne 2

Defineerida meetod lookup, mis implementeerib seoste järjendist otsimise. Sobiva väärtuse mitteleidmisel tagastada -1. (Sõne ja täisarvu paari tüüp on (String, Int).)

object Programm2 {
  def lookup(alist: Seq[(String, Int)], a:String): Int = ???

  def main(args: Array[String]): Unit = {
    val alist = Seq(("kala", 12), ("maja", 3), ("saba", 1), ("pala", 2))
    printf("pala = %d\n", lookup(alist,"pala")) // trükib: pala = 2
  }
}

Ülesanne 3

Muuda jägnevat programmi nii, et see tõepoolest arvude keskmise väärtuse välja arvutaks.

object Programm3 {
  def printSeq (s:Seq[Int]): Unit = {
    var i = 0
    for (i <- s){
      printf("%d\n", i)
    }
  }

  def main(args: Array[String]): Unit = {
    printf("Tere Päevast!\n")
    val x = Seq(3,2,1)
    val y = 0.0

    printf("Arvude:\n")
    printSeq(x)
    printf("keskmine väärtus on %f\n", y)
  }
}

Ülesanne 4

Lõpetada järgneva RPN-kalkulaator implementatsioon. Töötama peab liitmine, lahutamine, korrutamine ja jagamine. 2*(3+4) tuleb sisestada kui 2 3 4 + *

(vaata: https://en.wikipedia.org/wiki/Reverse_Polish_notation)

object Programm4 {
  val stack = mutable.Stack[Double]()

  def liida() = {
    stack.push(stack.pop+stack.pop)
  }

  def dialoog():Unit = {
    val inps = StdIn.readLine.split("[ ]+")
    for (inp <- inps) {
      if (inp == "+") {
        liida()
      } else try {
        stack.push(inp.toDouble)
      } catch {
        case e:java.lang.NumberFormatException =>
          printf("Viga! Proovi uuesti!\n")
      }
    }
  }

  def main(args: Array[String]): Unit = {
    dialoog()
    printf("Vastus: %.2f\n", stack.top)
  }
}

Ülesanne 5

Sõbralik ettevõtja Kersti võttis suveürituste jaoks tööle viis koolilast, kes on kõvasti vaeva näinud. Aga kokku on lepitud nii, et palk makstakse välja hoopis laste vanematele --- niisiis tuleb ühe pere laste palgad liita. Kersti on jõudnud laste palgad juba üles kirjutada, kuid tal on vaja veel implementeerida meetod palgaSumma, mis teise argumendis olevate nimede järgi just nende laste palkade summa leiab. (Kersti tahab kirjutada seda for-tsükkliga!)

Vii lõpuni Kersti programmi implementeerimine!

object Programm7 {
 def palgaSumma(m: Map[String, Int], ys: Seq[String]): Int = ???


  def main(args: Array[String]) {
    val palgad = Map("Jüri" -> 140, "Peeter" -> 30, "Jaana" -> 90,
      "Mirjam" -> 180, "Paul" -> 70)

    printf("Jüri palk on: %d\n", palgad("Jüri"))
    printf("Summa: %d\n", palgaSumma(palgad, Seq("Paul","Jaana")))
  }
}