Functions and lambdas in Android Kotlin - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a function named greet that takes no parameters and returns a String.

Android Kotlin

fun greet(): [1] {
  return "Hello!"
}

Drag options to blanks, or click blank then click option'

ABoolean

BInt

CUnit

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using Unit as return type when function returns a value.

Using Int or Boolean instead of String.

The function greet returns a String, so the return type must be String.

2fill in blank

medium

Complete the code to define a lambda that takes two Ints and returns their sum.

Android Kotlin

val sum: (Int, Int) -> Int = [1]

Drag options to blanks, or click blank then click option'

A{ a, b -> a * b }

B(a, b) -> a - b

C{ a, b -> a + b }

D(a, b) -> a / b

Attempts:

3 left

💡 Hint

Common Mistakes

Using parentheses instead of curly braces for lambda body.

Using subtraction or multiplication instead of addition.

The lambda syntax uses curly braces with parameters and an arrow, here adding a and b.

3fill in blank

hard

Fix the error in the function declaration to make it a valid Kotlin function that returns Unit.

Android Kotlin

fun printMessage(message: String)[1] {
  println(message)
}

Drag options to blanks, or click blank then click option'

A: Unit

B-> Unit

C-> String

D: String

Attempts:

3 left

💡 Hint

Common Mistakes

Using '-> Unit' which is invalid syntax for function return type.

Using String as return type when function returns nothing.

In Kotlin, functions returning Unit use ': Unit' after the parameter list.

4fill in blank

hard

Fill both blanks to create a lambda that filters a list of Ints to only even numbers.

Android Kotlin

val evens = numbers.filter { [1] -> [2] % 2 == 0 }

Drag options to blanks, or click blank then click option'

Anum

Bnumber

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for parameter and inside the lambda body.

Using invalid variable names.

The lambda parameter name must be consistent; here 'number' is used for both parameter and in the body.

5fill in blank

hard

Fill all three blanks to create a function that takes a lambda and calls it with 5.

Android Kotlin

fun callWithFive(action: (Int) -> Unit) {
  action([1])
}

callWithFive { [2] -> println([3]) }

Drag options to blanks, or click blank then click option'

A5

Bx

D10

Attempts:

3 left

💡 Hint

Common Mistakes

Passing wrong value to the lambda.

Using different names for lambda parameter and inside body.

The function calls the lambda with 5; the lambda parameter is named x and printed.

Practice

1. What is a lambda function in Kotlin?
val sum = { a: Int, b: Int -> a + b }

easy

A. A function that must have a name and cannot be stored

B. An unnamed function that can be stored in a variable

C. A special class for storing data

D. A type of loop for repeating code

Solution

1. Step 1: Understand lambda syntax

   The code { a: Int, b: Int -> a + b } defines a function without a name.

2. Step 2: Identify lambda characteristics

   This function is stored in the variable sum, showing it is unnamed but reusable.

3. Final Answer:

   An unnamed function that can be stored in a variable -> Option B

4. Quick Check:

   Lambda = unnamed function stored in variable [OK]

Hint: Lambdas have no name and are assigned to variables [OK]

Common Mistakes:

• Thinking lambdas must have names
• Confusing lambdas with classes
• Assuming lambdas are loops

2. Which of the following is the correct syntax to declare a lambda that takes no parameters and returns a String "Hello"?

easy

A. val greet = fun() { return "Hello" }

B. val greet = () -> "Hello"

C. val greet = { -> "Hello"

D. val greet = { "Hello" }

Solution

1. Step 1: Review lambda syntax for no parameters

   Lambdas with no parameters use { expression } syntax.

2. Step 2: Check each option

   val greet = { "Hello" } correctly uses { "Hello" }. val greet = { -> "Hello" missing closing brace, B is function type syntax, D is a named function.

3. Final Answer:

   val greet = { "Hello" } -> Option D

4. Quick Check:

   No-parameter lambda = { value } [OK]

Hint: Use { expression } for lambdas with no parameters [OK]

Common Mistakes:

• Missing closing brace in lambda
• Confusing lambda with function type syntax
• Using fun keyword inside lambda

3. What is the output of this Kotlin code?

val multiply = { x: Int, y: Int -> x * y }
println(multiply(3, 4))

medium

A. 7

B. 34

C. 12

D. Error

Solution

1. Step 1: Understand the lambda function

   The lambda { x: Int, y: Int -> x * y } multiplies two integers.

2. Step 2: Calculate the result of multiply(3, 4)

   3 * 4 equals 12, so the printed output is 12.

3. Final Answer:

   12 -> Option C

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply inputs inside lambda to get output [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Expecting syntax error

4. Identify the error in this Kotlin lambda declaration:

val greet = { name: String ->
  println("Hello, " + name)
}

medium

A. No error, this is valid syntax

B. Cannot use println inside lambda

C. Missing return type declaration

D. Lambda must return a value, println returns Unit

Solution

1. Step 1: Check lambda syntax

   The lambda takes a String parameter and calls println, which is allowed.

2. Step 2: Confirm return type flexibility

   Lambdas can return Unit (like void), so no return type declaration is needed.

3. Final Answer:

   No error, this is valid syntax -> Option A

4. Quick Check:

   Lambda with println is valid [OK]

Hint: Lambdas can return Unit; println is allowed [OK]

Common Mistakes:

• Expecting return type declaration
• Thinking println is disallowed
• Confusing Unit with error

5. You want to filter a list of numbers to keep only even numbers using a lambda. Which code correctly does this?

val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter( /* fill here */ )
println(evens)

hard

A. numbers.filter { it % 2 == 0 }

B. numbers.filter { x -> x / 2 == 0 }

C. numbers.filter { it % 2 = 0 }

D. numbers.filter { it & 2 == 0 }

Solution

1. Step 1: Understand filtering with lambda

   The filter lambda should return true for even numbers using modulo operator.

2. Step 2: Evaluate each option

   numbers.filter { it % 2 == 0 } correctly uses it % 2 == 0. numbers.filter { x -> x / 2 == 0 } uses division instead of modulo, C uses assignment (=) instead of comparison (==), A uses bitwise AND incorrectly.

3. Final Answer:

   numbers.filter { it % 2 == 0 } -> Option A

4. Quick Check:

   Filter even numbers with modulo == 0 [OK]

Hint: Use it % 2 == 0 to check even numbers in filter [OK]

Common Mistakes:

• Using = instead of == for comparison
• Using division instead of modulo
• Misusing bitwise operators