Map creation (mapOf, mutableMapOf) in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code?

Consider the following Kotlin code snippet. What will be printed when it runs?

Kotlin

val map = mapOf("a" to 1, "b" to 2, "c" to 3)
println(map["b"])

A null

B b

C 2

D 1

💡 Hint

Look at how the map is created and how the value is accessed by key.

The map contains keys "a", "b", and "c" with values 1, 2, and 3 respectively. Accessing map["b"] returns 2.

❓ Predict Output

intermediate

What happens when you modify a mutable map?

What will be the output of this Kotlin code?

Kotlin

val mutableMap = mutableMapOf("x" to 10, "y" to 20)
mutableMap["x"] = 15
println(mutableMap["x"])

A 15

B null

C 20

D 10

💡 Hint

mutableMapOf allows changing values after creation.

The mutable map allows updating the value for key "x" from 10 to 15, so printing mutableMap["x"] outputs 15.

❓ Predict Output

advanced

What is the output of this Kotlin code with mapOf and null key?

Analyze this Kotlin code and select the output it produces.

Kotlin

val map = mapOf(null to "empty", "key" to "value")
println(map[null])

A empty

B null

C value

D Compilation error

💡 Hint

Kotlin maps can have null keys unless specified otherwise.

The map contains a null key with value "empty". Accessing map[null] returns "empty".

❓ Predict Output

advanced

What error does this Kotlin code raise?

What error will this Kotlin code produce when run?

Kotlin

val map = mapOf("a" to 1, "b" to 2)
map["a"] = 3

A UnsupportedOperationException

B Unresolved reference: set

C No error, prints 3

D NullPointerException

💡 Hint

mapOf creates an immutable map, so you cannot change values.

Trying to assign a value to a key in an immutable map results in a compilation error: Unresolved reference: set.

🧠 Conceptual

expert

How many entries does this Kotlin map contain?

Given the following Kotlin code, how many key-value pairs does the map contain?

Kotlin

val map = mutableMapOf("one" to 1, "two" to 2)
map.put("three", 3)
map["two"] = 22
map.remove("one")

A 3

B 4

C 1

D 2

💡 Hint

Consider all insertions, updates, and removals carefully.

Initially, the map has 2 entries. Adding "three" to 3 makes 3 entries. Updating "two" does not change count. Removing "one" leaves 2 entries.

Practice

1. What does mapOf create in Kotlin?

easy

A. A list of values without keys

B. A mutable map that can be changed later

C. A fixed map that cannot be changed after creation

D. An empty map with no keys or values

Solution

1. Step 1: Understand mapOf purpose

   mapOf creates a map with key-value pairs that cannot be modified after creation.

2. Step 2: Compare with other map types

   mutableMapOf allows changes, but mapOf does not.

3. Final Answer:

   A fixed map that cannot be changed after creation -> Option C

4. Quick Check:

   mapOf = fixed map [OK]

Hint: Remember: mapOf = fixed map, mutableMapOf = changeable map [OK]

Common Mistakes:

• Confusing mapOf with mutableMapOf
• Thinking mapOf creates an empty map
• Assuming mapOf allows adding new entries

2. Which of the following is the correct syntax to create a mutable map with keys "a" and "b" and values 1 and 2 respectively?

easy

A. val map = mutableMapOf("a" to 1, "b" to 2)

B. val map = mapOf("a" -> 1, "b" -> 2)

C. val map = mutableMapOf("a" = 1, "b" = 2)

D. val map = mapOf("a" to 1, "b" to 2)

Solution

1. Step 1: Identify correct syntax for mutableMapOf

   The correct syntax uses mutableMapOf with pairs using to keyword.

2. Step 2: Check each option

   val map = mutableMapOf("a" to 1, "b" to 2) uses mutableMapOf and to correctly. val map = mapOf("a" -> 1, "b" -> 2) uses wrong arrow ->. val map = mutableMapOf("a" = 1, "b" = 2) uses = which is invalid here. val map = mapOf("a" to 1, "b" to 2) uses mapOf which creates an immutable map.

3. Final Answer:

   val map = mutableMapOf("a" to 1, "b" to 2) -> Option A

4. Quick Check:

   mutableMapOf + to = correct syntax [OK]

Hint: Use mutableMapOf with "key" to value pairs [OK]

Common Mistakes:

• Using -> instead of to for pairs
• Using = inside mapOf or mutableMapOf
• Confusing mapOf and mutableMapOf

3. What is the output of this Kotlin code?

val map = mapOf("x" to 10, "y" to 20)
println(map["x"])
println(map["z"])

medium

A. 20
null

B. 10
null

C. null
null

D. 10
0

Solution

1. Step 1: Access existing key "x"

   map["x"] returns 10 because "x" is a key with value 10.

2. Step 2: Access non-existing key "z"

   map["z"] returns null because "z" is not in the map.

3. Final Answer:

   10\nnull -> Option B

4. Quick Check:

   Existing key returns value, missing key returns null [OK]

Hint: map[key] returns value or null if key missing [OK]

Common Mistakes:

• Expecting 0 instead of null for missing key
• Confusing values of different keys
• Assuming map is mutable and can add keys

4. What is wrong with this Kotlin code?

val map = mapOf("a" to 1)
map["b"] = 2

medium

A. mapOf creates an immutable map, so you cannot add new entries

B. The syntax for adding entries is incorrect; should use put()

C. Keys must be integers, not strings

D. mapOf requires mutableMapOf to add entries

Solution

1. Step 1: Understand mapOf immutability

   mapOf creates an immutable map that cannot be changed after creation.

2. Step 2: Adding entries to immutable map causes error

   Trying to assign a new key-value pair with map["b"] = 2 causes a compile-time error because the map is immutable.

3. Final Answer:

   mapOf creates an immutable map, so you cannot add new entries -> Option A

4. Quick Check:

   Immutable map cannot be changed [OK]

Hint: Use mutableMapOf to add or change entries [OK]

Common Mistakes:

• Trying to add entries to mapOf
• Using wrong syntax for adding entries
• Confusing mutableMapOf and mapOf

5. You want to create a map that stores student names as keys and their scores as values. You also want to update scores later. Which Kotlin code snippet correctly achieves this?

hard

A. val scores = mutableMapOf("Alice" to 90, "Bob" to 85)
scores.add("Alice", 95)

B. val scores = mapOf("Alice" to 90, "Bob" to 85)
scores["Alice"] = 95

C. val scores = mapOf("Alice" to 90, "Bob" to 85)
scores.put("Alice", 95)

D. val scores = mutableMapOf("Alice" to 90, "Bob" to 85)
scores["Alice"] = 95

Solution

1. Step 1: Choose a mutable map to allow updates

   Since scores need to be updated, mutableMapOf is required.

2. Step 2: Use correct method to update value

   Assigning with scores["Alice"] = 95 correctly updates the value in a mutable map.

3. Step 3: Check other options for errors

   val scores = mapOf("Alice" to 90, "Bob" to 85) scores["Alice"] = 95 uses immutable map and tries to update, causing error. val scores = mapOf("Alice" to 90, "Bob" to 85) scores.put("Alice", 95) tries to use put on immutable map, error. val scores = mutableMapOf("Alice" to 90, "Bob" to 85) scores.add("Alice", 95) uses non-existent add method.

4. Final Answer:

   val scores = mutableMapOf("Alice" to 90, "Bob" to 85) scores["Alice"] = 95 -> Option D

5. Quick Check:

   mutableMapOf + assignment updates map [OK]

Hint: Use mutableMapOf and bracket assignment to update entries [OK]

Common Mistakes:

• Using mapOf when updates are needed
• Trying to use put on immutable map
• Using add method which does not exist