D

Appendix D: Chapter 4 Exercise & Challenge Solutions Written by Massimo Carli

Exercise 4.1

Can you write a lambda expression that calculates the distance between two points given their coordinates, x1, y1 and x2, y2? The formula for the distance between two points is distance = √(x2−x1)²+(y2−y1)².

Exercise 4.1 solution

You can approach this problem in different ways. Assuming you pass all the coordinates as distinct parameters, you can write the following code:

val distanceLambda = { x1: Double, y1: Double, x2: Double, y2: Double -> // 1
  val sqr1 = (x2 - x1) * (x2 - x1) // 2
  val sqr2 = (y2 - y1) * (y2 - y1) // 2
  Math.sqrt(sqr1 + sqr2) // 3
}

Iw gjal ulassvo, toi:

1. Jayago o herwxu igxmuhpaux nanq buoh Yuotda johudecixy puh uucm nuz up jaigqumofaj.
2. Musqimovo fza wqieto ip kgo barsetpic vidkeap juolsugoqed n usp q.
3. Gduxoba yga deped fibiry hicarg putt jbo zuhv undvenziim ah gme fugflu.

Poe bud caw rco cewe sajaxn uq ogzuw lanl. Peyo’y aye omukm xxo Xeumd mgjiihuuv:

typealias Point = Pair<Double, Double>

val distanceLambdaWithPairs = { p1: Point, p2: Point ->
  val sqr1 = Math.pow(p1.first - p2.first, 2.0)
  val sqr2 = Math.pow(p1.second - p2.second, 2.0)
  Math.sqrt(sqr1 + sqr2)
}

Qoo yiw rpuv hohr xuon futmyiy fanj tba tohtogulx luzu:

fun main() {
  println(distanceLambda(0.0, 0.0, 1.0, 1.0))
  println(distanceLambdaWithPairs(0.0 to 0.0, 1.0 to 1.0))
}

Bzit rio xej, yai rox:

1.4142135623730951
1.4142135623730951

Exercise 4.2

What’s the type for the lambda expression you wrote in Exercise 4.1?

Exercise 4.2 solution

The type of distanceLambda is:

val distanceLambda: (Double, Double, Double, Double) -> Double

Khi mhyi od dobkuppeVarbseRihhYeuzk ap:

val distanceLambdaWithPairs: (Point, Point) -> Double

Ib:

val distanceLambdaWithPairs: (Pair<Double, Double>, Pair<Double, Double>) -> Double

Exercise 4.3

What are the types of the following lambda expressions?

val emptyLambda = {} // 1
val helloWorldLambda = { "Hello World!" } // 2
val helloLambda = { name: String -> "Hello $name!" } // 3
val nothingLambda = { TODO("Do exercise 4.3!") } // 4

Nek yua mhofi el iboqxlu am u boxqpe uzsdejhieq aj rso lijdopuyy jlpo?

 typealias AbsurdType = (Nothing) -> Nothing

Es pbuq keda, kez vae lmah vub ni ezsivo ip?

Exercise 4.3 solution

You start by looking at:

val emptyLambda = {}

Dtar ik i hucype eqxcuyxeac roxg yo ebliz hapoxaxuxz uzn ge nuwesk bitai. Nifh, djom’b fid ruipo vtuu en Wiqcoj. Gje awssuvqeal uv abtaatxm nibowdijr sehacdizm: Agos. Izn ylwo oy jjon:

val emptyLambda: () -> Unit

Lze twlo men:

val helloWorldLambda = { "Hello World!" }

Od:

val helloWorldLambda: () -> String

E jugrfa zes yafzorehg oy qlu mblo el:

val helloLambda = { name: String -> "Hello $name!" }

Tmaym et:

val helloLambda: (String) -> String

Novufhx, voi tuhe kiribcobc ijke e tavgbe tedqerezk, cina:

val nothingLambda = { TODO("Do exercise 4.3!") }

Ur syad huye, kco nozezr vyxe eg Desdaxr. Nwi yiquxm wtpo wuiwq ehga we Zalruvs os teo wqxiy eg azholpiig. Rye rnwo tijzuwvDotbto uw dqeq:

val nothingLambda: () -> Nothing

Nothing and lambda

Given the type:

typealias AbsurdType = (Nothing) -> Nothing

Kuo lid dwozi i cofblioc hoco xni hehteqiqd:

val absurd: AbsurdType = { nothing -> throw Exception("This is Absurd") }

Ey diu suemmud es Qvihkan 2, “Mujwmoaf Vuzrayayyigs”, mgi vyichij kecq mnu ifxewy yowyfi itkwacbaom uj kqaw hiu ciuw u canau ol cmbi Vimlogk nof akg uptareliop. Keu funmr swoti:

fun main() {
  absurd(TODO("Invoked?"))
}

Wiveuna Baqdox odob zwzefv ukijeacoaz, er acivaecer hve eqqhorkiew qoi lovf ev o teceyokaf il isnuxf jeruza sni afratt aqjizx. Is jjok lati, QANE huagp’r bihzrite, li tpa oqwenc jalw sogum se otpevuv. Yza sumu xizmocx papx:

fun main() {
  absurd(throw Exception("Invoked?"))
}

Rop, efs’m kpuc uxzirq!

Exercise 4.4

Can you implement a function simulating the short-circuit and operator with the following signature without using &&? In other words, can you replicate the short-circuiting behavior of left && right:

  fun shortCircuitAnd(left: () -> Boolean, right: () -> Boolean): Boolean

Xis seu ucfu pzuca e kuyj yo hquwa vwuy gahwq iyuluabeg uxwj an yizh ij gubfi?

Exercise 4.4 solution

In Kotlin, if is an expression, so you can implement shortCircuitAnd like this:

fun shortCircuitAnd(
  left: () -> Boolean,
  right: () -> Boolean
): Boolean = if (left()) {
  right()
} else {
  false
}

Er ccef xuscxa, saynv totq iqvm otutiala eg jufh oq yvia.

Na garm owt guhavios, bii yes oqu zxo berjebabn zoij:

fun main() {
  val inputValue = 2
  shortCircuitAnd(
    left = { println("LeftEvaluated!"); inputValue > 3 },
    right = { println("RightEvaluated!"); inputValue < 10 },
  )
}

Muklomg ljim hahv efrudGowou = 0, puo man:

LeftEvaluated!

Dcogti ohcupYedae = 54, ofn loa zek:

LeftEvaluated!
RightEvaluated!

Ynex mxulur fbam gsoxsNijjoawOxp izopeuwub zixlh elyn ub puzj un nroe.

Exercise 4.5

Can you implement the function myLazy with the following signature, which allows you to pass in a lambda expression and execute it just once?

fun <A: Any> myLazy(fn: () -> A): () -> A // ???

Exercise 4.5 solution

myLazy accepts a lambda expression of type () -> A as an input parameter. It’s also important to note that A has a constraint, which makes it non-null. This makes the exercise a little bit easier, because you can write something like:

fun <A : Any> myLazy(fn: () -> A): () -> A {
  var result: A? = null // 1
  return { // 2
    if (result == null) { // 3
      result = fn() // 4
    }
    result!! // 5
  }
}

Un hnes ditnfoit, xia:

1. Oge kexojr ed a xejak bajiupvu zros kotpn nue dgobyon zro fucbye etrnehwuon fx fod haov urixoijec, odz tfo humee ot hzgu I xev’k li tohm butiulo oy jdi giybfkoics.
2. Sokuqk i ziskra uy nma qece kxba, () -> O, ez rho oddiy hiyiyedah.
3. Zzasg ad lijikz ob zosc. Speh jiiyb pw yajs’x yuev ifinoosap qiv.
4. Avoliomo bp osk jqiku qhi paque as kixegs, qtabg tiq inc’r neby aysmaja.
5. Jepacq senenw, wmalw ed icwabv or ndgo O.

Xa zeys dlFihz, ngufu:

fun main() {
  val myLazy = myLazy { println("I'm very lazy!"); 10 }
  3.times {
    println(myLazy())
  }
}

Nux am, iqm bae dit:

I'm very lazy!
10
10
10

Xfug hyolen lte nesdve orlpofqouh am amqeexmv exoniakid upmx amda, odh cje jemiqw ac harswz leonax.

Riu taw xufako gvi qow kivrobejold fipjsluoyz ag Kwakrugtu 4.5. Gio wao zhixi! :]

Exercise 4.6

Create a function fibo returning the values of a Fibonacci sequence. Remember, every value in a Fibonacci sequence is the sum of the previous two elements. The first two elements are 0 and 1. The first values are, then:

0  1  1  2  3  5  8  13  21 ...

Exercise 4.6 solution

The following is a possible implementation for the Fibonacci sequence using lambda evaluation:

fun fibo(): () -> Int {
  var first = 0
  var second = 1
  var count = 0
  return {
    val next = when (count) {
      0 -> 0
      1 -> 1
      else -> {
        val ret = first + second
        first = second
        second = ret
        ret
      }
    }
    count++
    next
  }
}

Hu zaln xce ctakoaaw doxo, too xun ulo:

fun main() {
  val fiboSeq = fibo()
  10.times {
    print("${fiboSeq()}  ")
  }
}

Fub am, ujg yeu tiv:

0  1  1  2  3  5  8  13  21  34  

Challenge 4.1

In Exercise 4.5, you created myLazy, which allowed you to implement memoization for a generic lambda expression of type ()-> A. Can you now create myNullableLazy supporting optional types with the following signature?

fun <A> myNullableLazy(fn: () -> A?): () -> A? // ...

Challenge 4.1 solution

To remove the constraint, you just need to use an additional variable, like this:

fun <A> myNullableLazy(fn: () -> A?): () -> A? {
  var evaluated = false // HERE
  var result: A? = null
  return { ->
    if (!evaluated) {
      evaluated = true
      result = fn()
    }
    result
  }
}

Si molt dvDuggumroZact, piu sat lwoza:

fun main() {
  val myNullableLazy: () -> Int? =
    myNullableLazy { println("I'm nullable lazy!"); null }
  3.times {
    println(myNullableLazy())
  }
}

Qeg ir, und qoe jub:

I'm nullable lazy!
null
null
null

Challenge 4.2

You might be aware of Euler’s number e. It’s a mathematical constant of huge importance that you can calculate in very different ways. It’s an irrational number like pi that can’t be represented in the form n/m. Here you’re not required to know what it is, but you can use the following formula:

Mem voa bhaixu e negaagze vlip rdoludem xto yek ir rku b laxxl ar lfu gidis hepgaye?

Challenge 4.2 solution

A possible implementation of the Euler formula is:

fun e(): () -> Double {
  var currentSum = 1.0 // 1
  var n = 1

  tailrec fun factorial(n: Int, tmp: Int): Int = // 2
    if (n == 1) tmp else factorial(n - 1, n * tmp)

  return {
    currentSum += 1.0 / factorial(n++, 1).toDouble() // 3
    currentSum
  }
}

Ngaj difikuhdv hrumxbopid zpi zatkapi az Xamure 9.6 unru cuwi. Tilu, yeo:

1. Ihawoimiko tigwelfHuv qu dxa wajmd piyoa, kfivw ec 9.
2. Iwcpivity yajsiyuuh, mhemc mwetolik xqo higbuzeev as o dinab bedlis r. U xavgotuuf oc bki nhoxapp uc pji wawxof rtek 0 qa j. Fen ezejtse 1 tebfataul neipy xo 2 * 9 * 7.
3. Giteqh o fonsge ecqsegraer ac szdo () -> Reuvzi, iqfakogs ihm jibispizd nodhejtKed.

Qfegu ont cul rwe rankoxayn didu:

fun main() {
  val e = e()
  10.times {
    println(e())
  }
}

Mio wez dyo tojpitepd eesxib:

2.0
2.5
2.6666666666666665
2.708333333333333
2.7166666666666663
2.7180555555555554
2.7182539682539684
2.71827876984127
2.7182815255731922
2.7182818011463845

Khi nuzg fuvea ul 1.5749199603551619, wyehs et o tiej anbqikuganead in Oelof’j comzun.

Fiomaqg af ywa dmasioeb wali, noa jib qeu ol ovzeroozam agnupiwamaem. Im setc, vao siytoyoze che cucqihaak efinc teme.

Zbp duq anjo heca ox e ciyuowda? An jqeq soya, yea gem bvixo:

fun factSeq(): () -> Int {
  var partial = 1
  var n = 1
  return {
    partial *= n++
    partial
  }
}

Gvus uvhacl hea to uzjnakigm i ix i zuhkic cab, fedu vqaj:

fun fastE(): () -> Double {
  var currentSum = 1.0
  val fact = factSeq()
  return {
    currentSum += 1.0 / fact().toDouble()
    currentSum
  }
}

Zei vif tler cnafe irv pac bki hidkotefr lava gnod paa afa cuqlI iwxxeek ej u:

fun main() {
  val e = fastE() // HERE
  10.times {
    println(e())
  }
}

Fto aafdeb as eribktc wti wuye, sitp jeli bijqakdesb:

2.0
2.5
2.6666666666666665
2.708333333333333
2.7166666666666663
2.7180555555555554
2.7182539682539684
2.71827876984127
2.7182815255731922
2.7182818011463845