Programming Languages 2020/21 fall

1. Scala kodutöö

Moodle'ist leiad ka lahendusfaili malli Kt1.scala.

1. ülesanne (0.5p)

Korduvate elementidega listi tuvastamine. Kirjuta (näiteks kasutades mustrisobitust ja rekursiooni) meetod korduvad, mis tagastab true parajasti siis kui listis leidub korduvaid elemente. Arvesta sellega, et korduvad elemendid ei pruugi olla listis järjest.

object Korduvad {
  def korduvad(l: List[Int]): Boolean = ???

  def main(args: Array[String]): Unit = {
    assert(!korduvad(List()))
    assert(!korduvad(List(1, 2, 3, 4)))
    assert(!korduvad(List(1, 2, 3, 4, 5)))
    assert(korduvad(List(1, 1)))
    assert(korduvad(List(1, 2, 3, 4, 4)))
    assert(korduvad(List(1, 4, 2, 3, 4)))
  }
}

2. ülesanne (0.5p)

Kasutades foldLeft, kirjuta meetod maksta, mis tagastab argumendiks saadud arvete hulgast mittemakstud arvete kogusumma.

object MaksaArved {
  class Arve {
    var summa   = 0d
    var toode   = ""
    var makstud = false
  }

  def maksta(as: List[Arve]): Double = {
    as.foldLeft(???)(???)
  }

  def main(args: Array[String]): Unit = {
    val a1 = new Arve; a1.toode = "A"; 
    a1.summa = 10; a1.makstud = false
    val a2 = new Arve; a2.toode = "B"; 
    a2.summa = 22; a2.makstud = true
    val a3 = new Arve; a3.toode = "B"; 
    a3.summa = 22; a3.makstud = false
    val a4 = new Arve; a4.toode = "A"; 
    a4.summa = 10; a4.makstud = false
    assert(maksta(List(a1, a2, a3, a4)) == 42)
    assert(maksta(List(a1, a2, a3)) == 32)
    assert(maksta(List(a1, a2, a4)) == 20)
    assert(maksta(List()) == 0)
  }

}

3. ülesanne (0.5p)

Kirjuta meetod kontrolliKontot, mis kontrollib, kas konto tehingute jooksul pole kunagi mindud miinusesse rohkem kui 1000 ühikut. Pane tähele et konto avatakse tühjalt.

object Krediidikontroll {
  type Raha = Int
  type KontoAjalugu = List[Raha]

  // Kui palju võib võlgu minna:
  def krediit: Raha = 1000

  def kontrolliKontot(konto: KontoAjalugu): Boolean = ???

  def main(args: Array[String]): Unit = {
    assert(kontrolliKontot(List(10,-5,20)))
    assert(kontrolliKontot(List(-1000)))
    assert(kontrolliKontot(List(-1000))) // kontrolliKontot kutsed peaksid olema sõltumatud
    assert(!kontrolliKontot(List(-1000,-1)))
    assert(!kontrolliKontot(List(10,-1000,10,-30,10000)))
  }
}

4. ülesanne (0.5p)

Tõlgi Haskelli funktsioon transpose Scalasse, meetodiks transponeeri.

object Transponeerimine {
  val m1 = List(List( 1, 2, 3),
                List(11,12,13),
                List(21,22,23))

  def prindiMaatriks(xss: List[List[Int]]): Unit = {
    for (xs <- xss) {
      for (x <- xs) {
        printf("%3d", x)
      }
      println()
    }
  }

  // Haskellis on järgneva funktsiooni nimi 'transpose'.
  // tr               :: [[a]] -> [[a]]
  // tr []             = []
  // tr ([]   : xss)   = tr xss
  // tr ((x:xs) : xss) = (x : map head xss]) : tr (xs : map tail xss)
  def transponeeri(m: List[List[Int]]): List[List[Int]] = ???

  def main(args: Array[String]): Unit = {
    prindiMaatriks(m1)
    println()
    prindiMaatriks(transponeeri(m1))
  }
}

Implementeeritav funktsioon peab kasutama etteantud mustrisobitust ja rekursiooni. S.t. ära kasuta siin standardteegi meetodit transpose.