Why Hash Map Exists and What Problem It Solves in DSA Go - Test Your Knowledge

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a map that stores string keys and integer values.

DSA Go

myMap := make(map[string][1])

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

Abool

Bstring

Cfloat64

Dint

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong value type like string or bool when integers are needed.

The map stores keys of type string and values of type int, so the value type must be int.

2fill in blank

medium

Complete the code to add a key-value pair to the map.

DSA Go

myMap[[1]] = 10

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

A10

B"apple"

CmyMap

Dkey

Attempts:

3 left

💡 Hint

Common Mistakes

Using a number or variable name without quotes as the key.

The key must be a string, so it should be in quotes like "apple".

3fill in blank

hard

Fix the error in the code to check if a key exists in the map.

DSA Go

value, [1] := myMap["banana"]

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

Aok

Bexists

Cfound

Dpresent

Attempts:

3 left

💡 Hint

Common Mistakes

Using variable names that are not conventional or cause confusion.

In Go, the second value returned when accessing a map is conventionally named ok to indicate if the key exists.

4fill in blank

hard

Fill both blanks to create a map that counts word occurrences only if the word length is greater than 3.

DSA Go

wordCount := map[string]int{}
for _, word := range words {
    if len(word) [1] 3 {
        wordCount[word] [2] wordCount[word] + 1
    }
}

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

A>

B=

C==

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using == instead of > in the condition.

Using == instead of = for assignment.

The condition checks if the word length is greater than 3 using >. To update the count, use = to assign the incremented value.

5fill in blank

hard

Fill all three blanks to create a map comprehension that stores uppercase words as keys and their lengths as values for words longer than 4 letters.

DSA Go

result := map[string]int{}
for _, word := range words {
    if len(word) [1] 4 {
        result[[2]] = [3]
    }
}

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

A>

Bword

Clen(word)

Dstrings.ToUpper(word)

Attempts:

3 left

💡 Hint

Common Mistakes

Using the word itself as key instead of uppercase.

Using wrong comparison operators.

The condition uses > to check length. The key is the uppercase word using strings.ToUpper(word). The value is the length of the word using len(word).

Practice

1. Why do we use a hash map instead of a simple list to store key-value pairs?

easy

A. Because lists use less memory than hash maps

B. Because hash maps store data in sorted order automatically

C. Because hash maps provide faster search for keys than lists

D. Because lists can only store numbers, not keys

Solution

1. Step 1: Understand list search time

   Searching for a key in a list requires checking each element one by one, which takes time proportional to the list size.

2. Step 2: Understand hash map search time

   Hash maps use a hash function to find the key's location quickly, making search much faster on average.

3. Final Answer:

   Because hash maps provide faster search for keys than lists -> Option C

4. Quick Check:

   Hash map = fast key search [OK]

Hint: Hash maps speed up key lookup compared to lists [OK]

Common Mistakes:

• Thinking lists are faster for key search
• Believing hash maps store data sorted
• Confusing memory use with speed

2. Which of the following is the correct way to declare a hash map in Go to store string keys and integer values?

easy

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

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

C. var m map[string]int = []string{}

D. var m map[string]int = {}

Solution

1. Step 1: Check map declaration syntax in Go

   In Go, a map is declared with 'var m map[keyType]valueType' and initialized with make().

2. Step 2: Validate each option

   var m map[string]int = make(map[string]int) correctly declares and initializes a map with string keys and int values. var m map[int]string = make(map[string]int) has mismatched types. var m map[string]int = []string{} uses slice syntax incorrectly. var m map[string]int = {} uses invalid initialization syntax.

3. Final Answer:

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

4. Quick Check:

   Go map syntax = var m map[string]int = make(map[string]int) [OK]

Hint: Use make() to initialize maps in Go [OK]

Common Mistakes:

• Using slice syntax instead of map
• Mismatching key and value types
• Forgetting to initialize with make()

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

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

medium

A. Compilation error

B. 53

C. 0

D. 8

Solution

1. Step 1: Understand map assignments

   The map 'm' stores integer values for keys "apple" and "banana" as 5 and 3 respectively.

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 accessing keys directly [OK]

Common Mistakes:

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

4. Identify the error in this Go code that uses a hash map:

m := make(map[string]int)
m["cat"] = 2
fmt.Println(m["dog"])

medium

A. Accessing a key that does not exist returns zero value, no error

B. Map must be declared with var keyword

C. Keys must be integers, not strings

D. Cannot print map values directly

Solution

1. Step 1: Check map initialization and usage

   The map is correctly initialized and assigned a value for key "cat".

2. Step 2: Understand accessing missing keys

   Accessing m["dog"] returns the zero value for int type, which is 0, without error.

3. Final Answer:

   Accessing a key that does not exist returns zero value, no error -> Option A

4. Quick Check:

   Missing key returns zero [OK]

Hint: Missing keys return zero value, no runtime error [OK]

Common Mistakes:

• Expecting runtime error on missing key
• Thinking keys must be integers
• Confusing map declaration syntax

5. You want to count how many times each word appears in a list of strings using a hash map in Go. Which approach correctly solves this problem?

hard

A. Initialize map[string]int, loop words, increment count for each word key

B. Use a slice of strings and append words, then count manually

C. Use a map[int]string with word counts as keys

D. Sort the list and count duplicates without a map

Solution

1. Step 1: Understand the counting problem

   We need to track how many times each word appears, so keys are words and values are counts.

2. Step 2: Choose correct data structure and method

   A map with string keys and int values lets us increment counts easily while looping through words.

3. Step 3: Evaluate other options

   Use a slice of strings and append words, then count manually uses a slice which is inefficient for counting. Use a map[int]string with word counts as keys swaps keys and values incorrectly. Sort the list and count duplicates without a map avoids map but is less efficient and more complex.

4. Final Answer:

   Initialize map[string]int, loop words, increment count for each word key -> Option A

5. Quick Check:

   Map counts words efficiently [OK]

Hint: Use map[word]count and increment in loop [OK]

Common Mistakes:

• Using wrong map key/value types
• Trying to count with slices only
• Ignoring map benefits for counting