Deleting map entries in Go - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output after deleting a key from a map?

Consider the following Go code that deletes a key from a map. What will be printed?

Go

package main
import "fmt"
func main() {
    m := map[string]int{"a": 1, "b": 2, "c": 3}
    delete(m, "b")
    fmt.Println(m)
}

A map[a:1 b:2 c:3]

B map[]

C map[b:2]

D map[a:1 c:3]

💡 Hint

Deleting a key removes it from the map, so it won't appear in the output.

The delete function removes the key "b" from the map. So the map only contains keys "a" and "c" after deletion.

❓ Predict Output

intermediate

What happens when deleting a non-existent key?

What will be the output of this Go program?

Go

package main
import "fmt"
func main() {
    m := map[int]string{1: "one", 2: "two"}
    delete(m, 3)
    fmt.Println(m)
}

A map[]

B map[3:]

C map[1:one 2:two]

D runtime error

💡 Hint

Deleting a key that does not exist does not cause an error.

Deleting a non-existent key does nothing. The map remains unchanged.

🔧 Debug

advanced

Why does this code cause a runtime panic?

This Go code tries to delete a key from a map but causes a runtime panic. What is the cause?

Go

package main
func main() {
    var m map[string]int
    delete(m, "key")
}

A The map m is nil and cannot be used with delete.

B The key "key" does not exist in the map.

C The delete function requires a pointer to the map.

D The map must be initialized with make before deleting.

💡 Hint

Check if the map is initialized before using delete.

A nil map cannot be used with delete; it causes a runtime panic.

❓ Predict Output

advanced

How many entries remain after deleting keys in a loop?

What is the length of the map after deleting keys in this Go code?

Go

package main
import "fmt"
func main() {
    m := map[int]int{1:10, 2:20, 3:30, 4:40}
    for k := range m {
        if k%2 == 0 {
            delete(m, k)
        }
    }
    fmt.Println(len(m))
}

A 2

B 4

C 0

D 3

💡 Hint

Keys 2 and 4 are even and get deleted.

Keys 2 and 4 are deleted, leaving keys 1 and 3, so length is 2.

🧠 Conceptual

expert

What is the behavior of deleting keys during map iteration?

In Go, what is the guaranteed behavior when deleting keys from a map while iterating over it?

A Deleting keys during iteration is safe and the iteration will skip deleted keys.

B The iteration order is undefined and deleting keys may cause some keys to be skipped or visited twice.

C Deleting keys during iteration causes a runtime panic.

D The map is copied before iteration, so deleting keys does not affect the iteration.

💡 Hint

Map iteration order is random and deleting keys affects iteration unpredictably.

Go's map iteration order is random and deleting keys during iteration can cause keys to be skipped or visited multiple times. This behavior is not guaranteed to be consistent.

Practice

1. What does the built-in delete function do in Go when used as delete(myMap, key)?

easy

A. Adds a new entry with the specified key to the map.

B. Returns the value associated with the key.

C. Clears all entries from the map.

D. Removes the entry with the specified key from the map if it exists.

Solution

1. Step 1: Understand the delete function purpose

   The delete function is used to remove a key and its value from a map.

2. Step 2: Analyze the effect of delete on the map

   When called as delete(myMap, key), it removes the entry if the key exists; otherwise, it does nothing.

3. Final Answer:

   Removes the entry with the specified key from the map if it exists. -> Option D

4. Quick Check:

   delete removes key from map [OK]

Hint: delete(map, key) removes key entry safely [OK]

Common Mistakes:

• Thinking delete adds or returns values
• Confusing delete with clearing the whole map
• Assuming delete returns a value

2. Which of the following is the correct syntax to delete a key named "user1" from a map called users in Go?

easy

A. delete(users, "user1")

B. users.delete("user1")

C. remove(users, "user1")

D. users.deleteKey("user1")

Solution

1. Step 1: Recall Go's delete syntax

   In Go, the built-in function delete is used as delete(map, key) to remove a key.

2. Step 2: Match the correct syntax

   delete(users, "user1") uses delete(users, "user1"), which is the correct syntax. Other options use methods that do not exist in Go.

3. Final Answer:

   delete(users, "user1") -> Option A

4. Quick Check:

   delete(map, key) syntax correct [OK]

Hint: Use delete(map, key) function, not method calls [OK]

Common Mistakes:

• Using method syntax like map.delete(key)
• Using non-existent functions like remove()
• Confusing with other languages' syntax

3. What will be the output of the following Go code?

m := map[string]int{"a": 1, "b": 2}
delete(m, "a")
fmt.Println(m)

medium

A. map[a:1 b:2]

B. map[b:2]

C. map[]

D. Compilation error

Solution

1. Step 1: Understand initial map content

   The map m initially has two entries: "a":1 and "b":2.

2. Step 2: Effect of delete(m, "a")

   The delete call removes the key "a" and its value from the map, leaving only "b":2.

3. Final Answer:

   map[b:2] -> Option B

4. Quick Check:

   Deleting key "a" removes it from map [OK]

Hint: Deleting key removes it; print shows remaining entries [OK]

Common Mistakes:

• Expecting deleted key to remain
• Thinking delete clears whole map
• Assuming syntax error occurs

4. Consider this Go code snippet:

var m map[string]int
delete(m, "key")
fmt.Println("Done")

What will happen when this code runs?

medium

A. Compilation error because delete cannot be used on nil maps.

B. Runtime panic due to deleting from a nil map.

C. Prints "Done" without error.

D. Deletes the key if it exists, then prints "Done".

Solution

1. Step 1: Understand nil map behavior

   In Go, a nil map behaves like an empty map for reads and deletes; deleting a key from a nil map does nothing and does not panic.

2. Step 2: Analyze the code behavior

   Deleting from a nil map is safe and does not cause runtime panic. The program prints "Done" normally.

3. Final Answer:

   Prints "Done" without error. -> Option C

4. Quick Check:

   Deleting from nil map is safe [OK]

Hint: Deleting from nil map is safe, no panic occurs [OK]

Common Mistakes:

• Assuming runtime panic on deleting from nil map
• Thinking delete causes compilation error
• Confusing nil map with uninitialized map variable

5. You have a map m := map[string]int{"x": 10, "y": 0, "z": -5}. You want to delete all keys whose values are zero or less. Which code snippet correctly deletes these entries?

hard

A. for k, v := range m { if v <= 0 { delete(m, k) } }

B. for k := range m { if m[k] < 0 { delete(m, k) } }

C. for k, v := range m { if v == 0 { delete(m, k) } }

D. for k := range m { if m[k] == 0 { delete(m, k) } }

Solution

1. Step 1: Identify keys with values zero or less

   Keys with values <= 0 are "y" (0) and "z" (-5).

2. Step 2: Choose loop that deletes keys with v <= 0

   for k, v := range m { if v <= 0 { delete(m, k) } } uses for k, v := range m and deletes keys where v <= 0, correctly removing "y" and "z".

3. Step 3: Compare other options

   Options A and C check only for == 0, missing negative values like "z":-5. for k := range m { if m[k] < 0 { delete(m, k) } } checks m[k] < 0, missing zero values like "y":0.

4. Final Answer:

   for k, v := range m { if v <= 0 { delete(m, k) } } -> Option A

5. Quick Check:

   Delete keys with value <= 0 using k,v loop [OK]

Hint: Use for k,v range and delete if v <= 0 [OK]

Common Mistakes:

• Deleting only keys with value == 0, missing negatives
• Using only key without value in loop
• Modifying map incorrectly during iteration