Hash Map vs Array vs Linked List for Lookup in DSA Go - Interactive Comparison Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an array of 5 integers.

DSA Go

arr := [5]int[1]

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

A{}

B{1, 2, 3, 4, 5}

C[]int{5}

D{0, 0, 0, 0, 0}

Attempts:

3 left

💡 Hint

Common Mistakes

Using slice syntax instead of array syntax.

Leaving the array empty without initialization.

The correct way to initialize an array of 5 integers with zeros is {0, 0, 0, 0, 0}.

2fill in blank

medium

Complete the code to check if a key exists in a Go map.

DSA Go

value, ok := myMap[[1]]

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

A"key"

Bkey

Cvalue

DmyMap

Attempts:

3 left

💡 Hint

Common Mistakes

Using the map name instead of the key.

Using the value variable instead of the key.

To check if a key exists in a map, use the key variable inside the brackets.

3fill in blank

hard

Fix the error in the linked list traversal code by completing the blank.

DSA Go

for current != nil {
    fmt.Println(current.value)
    current = current.[1]
}

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

Ahead

Bvalue

Cnext

Dprev

Attempts:

3 left

💡 Hint

Common Mistakes

Using prev instead of next.

Trying to access value as the next node.

To move to the next node in a linked list, use the next pointer.

4fill in blank

hard

Fill both blanks to create a map comprehension that stores word lengths for words longer than 3 characters.

DSA Go

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

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

A>

Blen(word)

C<

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > for length comparison.

Storing the word instead of its length.

We check if the word length is greater than 3 and then store the length in the map.

5fill in blank

hard

Fill all three blanks to create a map that stores keys and their values only if the value is positive.

DSA Go

result := map[string]int{}
for k, v := range data {
    if v [1] 0 {
        result[[2]] = [3]
    }
}

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

Ak.upper()

Bv

Ck

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using < instead of > for the value check.

Trying to uppercase the key incorrectly.

We check if the value is greater than 0, then store it with the original key in the result map.

Practice

1. Which data structure provides the fastest average lookup time for finding an element by key?

easy

A. Stack

B. Hash Map

C. Linked List

D. Array

Solution

1. Step 1: Understand lookup times for each data structure

   Hash Map uses hashing to find keys quickly, usually in constant time O(1). Arrays require scanning or index access, O(1) if index known but O(n) if searching by value. Linked Lists require scanning all nodes, O(n).

2. Step 2: Compare average lookup times

   Hash Map is fastest on average for key lookup because it directly computes the position. Arrays and Linked Lists are slower for searching by value.

3. Final Answer:

   Hash Map -> Option B

4. Quick Check:

   Fastest lookup by key = Hash Map [OK]

Hint: Hash Map uses keys for O(1) lookup, arrays and lists do not [OK]

Common Mistakes:

• Confusing array index access with searching by value
• Assuming linked list lookup is fast
• Thinking stack is a lookup structure

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

easy

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

B. var m = [string]int{}

C. var m = []int{}

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

Solution

1. Step 1: Identify correct Go syntax for hash map declaration

   In Go, maps are declared with 'map[keyType]valueType' and initialized with make(). var m map[string]int = make(map[string]int) uses 'map[string]int' and make(), which is correct.

2. Step 2: Check other options for errors

   var m = [string]int{} uses array syntax incorrectly. var m = []int{} is a slice, not a map. var m map[int]string = make(map[int]string) has reversed key and value types compared to question.

3. Final Answer:

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

4. Quick Check:

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

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

Common Mistakes:

• Using array or slice syntax instead of map
• Not initializing map with make()
• Swapping key and value types

3. You have a large dataset of unique user IDs and want to check membership efficiently. Which data structure should you choose and why? A hash map, an array, or a linked list?

easy

A. Array, because it stores elements contiguously for fast access

B. Linked List, because it uses less memory and is easy to insert

C. None, use a stack for membership checking

D. Hash Map, because it provides average O(1) lookup time for membership checks

Solution

1. Step 1: Understand membership check requirements

   Membership check means quickly finding if an element exists. For large datasets, speed matters.

2. Step 2: Compare data structures for membership check

   Array requires scanning O(n), linked list also O(n). Hash Map uses hashing for average O(1) lookup, best for membership.

3. Final Answer:

   Hash Map, because it provides average O(1) lookup time for membership checks -> Option D

4. Quick Check:

   Membership check fastest = Hash Map [OK]

Hint: Use hash map for fast membership checks in large data [OK]

Common Mistakes:

• Choosing array or list for fast membership
• Ignoring hash map average O(1) lookup
• Confusing stack with membership structure

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

package main
import "fmt"
func main() {
  arr := []int{10, 20, 30, 40}
  m := make(map[int]int)
  for i, v := range arr {
    m[v] = i
  }
  fmt.Println(m[30])
}

medium

A. 2

B. 30

C. 0

D. Compilation error

Solution

1. Step 1: Understand the loop and map assignment

   The loop iterates over array elements with index i and value v. It sets m[v] = i, so key is element value, value is index.

2. Step 2: Find the value for key 30 in map

   For element 30, index is 2, so m[30] = 2. Printing m[30] outputs 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   m[30] = index 2 [OK]

Hint: Map keys are array values, values are indices [OK]

Common Mistakes:

• Confusing key and value in map
• Expecting output 30 instead of index
• Thinking code has error

5. Identify the error in the following Go code that tries to find if a value exists in a linked list:

package main
import "fmt"

type Node struct {
  val int
  next *Node
}

func contains(head *Node, target int) bool {
  for head != nil {
    if head.val == target {
      return true
    }
    head = head.next
  }
  return false
}

func main() {
  var head *Node
  head.val = 10
  head.next = nil
  fmt.Println(contains(head, 10))
}

medium

A. Loop condition should be head.next != nil

B. Function contains has wrong return type

C. head is nil, so accessing head.val causes runtime panic

D. Missing import for fmt package

Solution

1. Step 1: Analyze initialization of head pointer

   head is declared as nil pointer. Accessing head.val without allocating Node causes runtime panic (nil pointer dereference).

2. Step 2: Check function and loop correctness

   Function contains is correct. Loop condition is correct.

3. Final Answer:

   head is nil, so accessing head.val causes runtime panic -> Option C

4. Quick Check:

   Nil pointer access causes panic [OK]

Hint: Initialize nodes before accessing fields to avoid nil panic [OK]

Common Mistakes:

• Ignoring nil pointer dereference
• Thinking loop condition is wrong
• Missing import is not main error