CH 2 - Functions

Question 1

In Kotlin, what value does an if expression return?

Answer 1

it returns a value based on the condition. Example:

val isHot = if (temperature > 40) true else false

Question 2

Unit-Returning Functions
What is a Unit in Kotlin, and when is it used?

Answer 2

Unit is a type that represents no meaningful value, similar to void in other languages. It is used for functions that don’t return a value. Example:
fun printHello(name: String?) {
println(“Hi there!”)
}

Question 3

How do default parameters work in Kotlin?

Answer 3

Default parameters provide a fallback value if no argument is passed. Example

fun drive(speed: String = “fast”) {
println(“driving $speed”)
}

Question 4

Required Parameters

Q: What happens if no default is specified for a parameter?

Answer 4

un tempToday(day: String, temp: Int) {
println(“Today is $day and it’s $temp degrees.”)
}

Question 5

why Named Arguments

Answer 5

Named arguments improve code readability by explicitly identifying the parameter name. Example:

reformat(str, divideByCamelHumps = false, wordSeparator = ‘_’)

Question 6

What are compact or single-expression functions in Kotlin?

Answer 6

these functions are written concisely in a single line. Example:

fun double(x: Int): Int = x * 2

Question 7

What is a lambda expression in Kotlin?

Answer 7

A lambda is an anonymous/ no name function. Example:

val waterFilter = { level: Int -> level / 2 }

Question 8

Higher-Order Functions

Answer 8

A higher-order function takes functions as parameters or returns a function. Example:

fun encodeMsg(msg: String, encode: (String) -> String): String {
return encode(msg)
}

Question 9

How do you pass a function reference in Kotlin?

Answer 9

Use the :: operator. Example:

encodeMessage(“abc”, ::enc2)

Question 10

List Filters.How do you filter a list in Kotlin?

Answer 10

Use the filter function with a condition. Example:

val books = listOf(“nature”, “biology”, “birds”)
println(books.filter { it[0] == ‘b’ })

Question 11

What’s the difference between eager and lazy filters in Kotlin?

Answer 11

eager filters evaluate immediately and return a new list, while lazy filters (using sequences) only evaluate when needed. Example of lazy filter:

Question 12

e.g of eager filter

Answer 12

val numbers = listOf(1, 2, 3, 4, 5)
val eager = numbers.filter { it > 2 } // Filters the list right away
println(eager) // Output: [3, 4, 5]

Question 13

e.g of lazy filter

Answer 13

val numbers = listOf(1, 2, 3, 4, 5)
val lazy = numbers.asSequence().filter { it > 2 } // Doesn’t filter yet
println(lazy.toList()) // Only filters when converted to a list
// Output: [3, 4, 5]

Question 14

Dry run the following code and predict the output:

val dirtLevel = 30
val waterFilter = { level: Int -> level / 3 }
println(waterFilter(dirtLevel))

Answer 14

10

Question 15

Rewrite the following function in a more compact form:

fun square(x: Int): Int {
return x * x
}

Answer 15

fun square(x: Int): Int = x * x

Question 16

Create a function that takes a string and returns it in reverse using a lambda. Then, dry run the function:

fun reverseString(input: String, reverse: (String) -> String): String {
return reverse(input)
}

val reverse = { str: String -> str.reversed() }
println(reverseString(“Kotlin”, reverse))

Answer 16

niltoK

Question 17

Use a lazy sequence to filter and print only strings starting with ‘a’ from a list:

val fruits = listOf(“apple”, “banana”, “apricot”, “grape”)
val filtered = fruits.asSequence().filter { it[0] == ‘a’ }
println(filtered.toList())

Answer 17

[“apple”, “apricot”]