Why maps are used in Go - Quick Recap

Recall & Review

beginner

What is a map in Go?

A map in Go is a built-in data type that stores key-value pairs. It allows you to quickly find a value by using its key, like a dictionary or a phone book.

beginner

Why do we use maps instead of arrays or slices?

Maps let you access data by a unique key instead of a numeric index. This makes it easier and faster to find specific information when the key is known.

intermediate

How do maps improve performance in Go programs?

Maps provide fast lookups, insertions, and deletions because they use a hash table internally. This means you can find or change data quickly without searching through all items.

beginner

Give a real-life example where maps are useful.

Maps are like a phone book where you look up a person's phone number by their name. In programming, you might use a map to store user information where the key is the username.

intermediate

What happens if you try to access a key that does not exist in a Go map?

If you access a key that does not exist, Go returns the zero value for the map's value type. You can also check if the key exists using a second return value.

What is the main advantage of using a map in Go?

A Fast access to values using keys

B Storing data in order

C Using numeric indexes only

D Automatically sorting data

Maps allow fast access to values by their keys, unlike arrays which use numeric indexes.

Which data structure does a Go map resemble in real life?

A Stack of books

B Phone book

C Queue line

D Calendar

A map is like a phone book where you look up a phone number by a person's name (key).

What does Go return if you access a map with a key that does not exist?

A Zero value of the value type

B An error message

C The last value stored

D A random value

Go returns the zero value for the map's value type if the key is missing.

Which operation is NOT efficient with maps?

A Finding a value by key

B Inserting a new key-value pair

C Deleting a key-value pair

D Accessing elements by numeric index

Maps do not support numeric index access; arrays or slices do.

What internal structure do Go maps use to provide fast lookups?

A Linked list

B Binary tree

C Hash table

D Array

Go maps use hash tables internally to achieve fast key-based lookups.

Explain why maps are useful in Go programming and give a simple example.

Think about how you find information quickly using a name or ID.

Describe what happens when you try to get a value from a Go map using a key that does not exist.

Remember Go's way of handling missing keys safely.

Practice

1. Why are maps used in Go programming?

easy

A. To create graphical user interfaces

B. To perform mathematical calculations

C. To store data with keys for fast lookup

D. To handle file input and output

Solution

1. Step 1: Understand the purpose of maps

   Maps store data in key-value pairs, allowing quick access to values using keys.

2. Step 2: Compare with other uses

   Maps are not used for calculations, GUI, or file handling, which are handled by other packages or types.

3. Final Answer:

   To store data with keys for fast lookup -> Option C

4. Quick Check:

   Maps = Fast key-based data access [OK]

Hint: Maps = key-value pairs for quick data access [OK]

Common Mistakes:

• Confusing maps with slices or arrays
• Thinking maps are for calculations
• Assuming maps handle files or UI

2. Which of the following is the correct way to create a map in Go?

easy

A. var m = map[string]int{1, 2, 3}

B. var m map[string]int = make(map[string]int)

C. var m = []int{1, 2, 3}

D. var m = make([]string, 5)

Solution

1. Step 1: Identify correct map creation syntax

   Maps are created using make with the syntax: make(map[keyType]valueType).

2. Step 2: Check each option

   var m map[string]int = make(map[string]int) uses make with map[string]int correctly. Options B and D create slices, and A has wrong map literal syntax.

3. Final Answer:

   var m map[string]int = make(map[string]int) -> Option B

4. Quick Check:

   Use make(map[key]value) to create maps [OK]

Hint: Use make(map[keyType]valueType) to create maps [OK]

Common Mistakes:

• Using slice syntax instead of map
• Forgetting to use make before adding items
• Incorrect map literal syntax

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

m := make(map[string]int)
m["apple"] = 5
m["banana"] = 3
fmt.Println(m["apple"] + m["banana"])

medium

A. 53

B. Compilation error

C. 0

D. 8

Solution

1. Step 1: Understand map assignments

   Keys "apple" and "banana" are assigned values 5 and 3 respectively in the map.

2. Step 2: Calculate the sum of values

   Adding m["apple"] (5) and m["banana"] (3) results in 8.

3. Final Answer:

   8 -> Option D

4. Quick Check:

   5 + 3 = 8 [OK]

Hint: Sum values by keys to get output [OK]

Common Mistakes:

• Concatenating values as strings
• Expecting zero for missing keys
• Thinking code has syntax errors

4. What is wrong with this Go code snippet?

var m map[string]int
m["key"] = 10
fmt.Println(m["key"])

medium

A. Map is not initialized with make before use

B. Key type should be int, not string

C. Value type should be string, not int

D. fmt.Println cannot print map values

Solution

1. Step 1: Check map initialization

   The map m is declared but not initialized with make, so it is nil and cannot store values.

2. Step 2: Understand consequences

   Assigning to a nil map causes a runtime panic. The map must be created with make before adding items.

3. Final Answer:

   Map is not initialized with make before use -> Option A

4. Quick Check:

   Use make to initialize maps before adding keys [OK]

Hint: Always initialize maps with make before adding items [OK]

Common Mistakes:

• Forgetting to initialize map before use
• Confusing map declaration with initialization
• Assuming fmt.Println can't print map values

5. You want to count how many times each word appears in a list of words using a map in Go. Which approach is correct?

hard

A. Create a map[string]int with make, then loop words and increment counts

B. Use a slice of strings and append each word multiple times

C. Create a map[int]string and store counts as keys

D. Use a single string variable to store all words concatenated

Solution

1. Step 1: Choose correct data structure

   Counting word occurrences requires a map with words as keys and counts as values, so map[string]int is suitable.

2. Step 2: Implement counting logic

   Initialize the map with make, then loop through the list, incrementing the count for each word key.

3. Final Answer:

   Create a map[string]int with make, then loop words and increment counts -> Option A

4. Quick Check:

   Use map[string]int to count word frequencies [OK]

Hint: Use map[string]int and increment counts in loop [OK]

Common Mistakes:

• Using slices instead of maps for counting
• Mixing key and value types in map
• Storing counts as keys instead of values