Character Frequency Counting in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of character frequency map after counting

What is the output of the following Go code that counts character frequencies in a string?

DSA Go

package main
import "fmt"
func main() {
    s := "hello"
    freq := make(map[rune]int)
    for _, ch := range s {
        freq[ch]++
    }
    fmt.Println(freq)
}

A map[h:1 e:1 l:2 o:1]

B map[104:1 101:1 108:1 111:1]

C map[101:1 104:1 108:2 111:1]

D map[104:1 101:1 108:2 111:1]

💡 Hint

Remember that Go prints rune keys as their integer Unicode code points in maps.

In Go, when printing a map with rune keys, the keys are shown as their integer Unicode code points. For example, 'h' is 104, 'e' is 101, 'l' is 108, and 'o' is 111. The frequency counts are correct for the string "hello".

🧠 Conceptual

intermediate

Understanding map key types in Go for character frequency

In Go, which map key type is best suited for counting frequency of characters in a string?

A rune

B byte

C string

D int

💡 Hint

Consider Unicode characters and multi-byte characters.

Using rune as the map key is best because it represents Unicode code points, allowing correct counting of all characters including multi-byte ones. byte only covers ASCII, and string keys would be inefficient for single characters.

🔧 Debug

advanced

Identify the error in character frequency counting code

What error will the following Go code produce when counting character frequency?

DSA Go

package main
import "fmt"
func main() {
    s := "abc"
    freq := make(map[string]int)
    for _, ch := range s {
        freq[ch]++
    }
    fmt.Println(freq)
}

A Compilation error: cannot use ch (type rune) as type string key in map

B Runtime panic: map key type mismatch

C Output: map[a:1 b:1 c:1]

D Output: map[97:1 98:1 99:1]

💡 Hint

Check the map key type and the type of variable used as key.

The map is declared with string keys but the loop variable ch is a rune. You cannot use a rune directly as a string key without conversion, so this causes a compilation error.

❓ Predict Output

advanced

Output of frequency counting with mixed Unicode characters

What is the output of this Go code counting frequencies of characters including emoji?

DSA Go

package main
import "fmt"
func main() {
    s := "a😊a"
    freq := make(map[rune]int)
    for _, ch := range s {
        freq[ch]++
    }
    fmt.Println(freq)
}

A map[97:2 128522:2]

B map[97:2 128522:1]

C map[97:1 128522:2]

D map[a:2 😊:1]

💡 Hint

Remember that emoji are represented by Unicode code points (runes).

The string contains 'a' twice (Unicode 97) and the emoji 😊 once (Unicode 128522). The map prints rune keys as integers, so the output shows counts accordingly.

🚀 Application

expert

Number of unique characters after frequency counting

After running the following Go code, what is the number of unique characters counted?

DSA Go

package main
import "fmt"
func main() {
    s := "GoLang 2024!"
    freq := make(map[rune]int)
    for _, ch := range s {
        if ch != ' ' {
            freq[ch]++
        }
    }
    fmt.Println(len(freq))
}

A 9

B 11

C 10

D 12

💡 Hint

Count all characters except spaces, including digits and punctuation.

The string "GoLang 2024!" without spaces has these unique characters: G, o, L, a, n, g, 2, 0, 4, ! — total 10 unique characters.

Practice

1. What does character frequency counting in a string help us find?

easy

A. How many times each character appears in the string

B. The length of the string

C. The first character of the string

D. The position of a character in the string

Solution

1. Step 1: Understand character frequency counting

   It means counting how many times each character shows up in a string.

2. Step 2: Compare with other options

   Length, first character, or position are different concepts, not frequency counting.

3. Final Answer:

   How many times each character appears in the string -> Option A

4. Quick Check:

   Frequency counting = count characters [OK]

Hint: Frequency means count of each character [OK]

Common Mistakes:

• Confusing frequency with string length
• Thinking frequency means position
• Mixing frequency with substring extraction

2. Which Go code snippet correctly initializes a map to count character frequencies?

easy

A. freq := make(map[rune]int)

B. freq := map[int]string{}

C. freq := []int{}

D. freq := make([]rune, 0)

Solution

1. Step 1: Identify correct map initialization for character counts

   We need a map with keys as characters (rune) and values as counts (int), so make(map[rune]int) is correct.

2. Step 2: Check other options

   freq := map[int]string{} uses wrong types (int keys, string values), C and D are slices, not maps.

3. Final Answer:

   freq := make(map[rune]int) -> Option A

4. Quick Check:

   Map for rune to int = freq map [OK]

Hint: Use map[rune]int for char frequency in Go [OK]

Common Mistakes:

• Using slice instead of map
• Wrong key or value types in map
• Not using make() for map initialization

3. What is the output of this Go code?

package main
import "fmt"
func main() {
  s := "hello"
  freq := make(map[rune]int)
  for _, ch := range s {
    freq[ch]++
  }
  fmt.Println(freq['l'])
}

medium

A. 3

B. 1

C. 2

D. 0

Solution

1. Step 1: Count occurrences of 'l' in "hello"

   The string "hello" has 'l' twice (positions 2 and 3).

2. Step 2: Check map frequency for 'l'

   freq['l'] increments twice, so freq['l'] = 2.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   Count of 'l' in "hello" = 2 [OK]

Hint: Count repeated chars carefully [OK]

Common Mistakes:

• Counting only once
• Confusing index with count
• Using wrong character in print

4. Find the error in this Go code for counting character frequency:

package main
import "fmt"
func main() {
  s := "test"
  freq := map[rune]int{}
  for i := 0; i < len(s); i++ {
    freq[s[i]] += 1
  }
  fmt.Println(freq)
}

medium

A. fmt.Println cannot print maps

B. Map freq is not initialized properly

C. Loop should use range instead of index

D. Using s[i] as byte instead of rune causes wrong map key type

Solution

1. Step 1: Check map key type and s[i] type

   Map keys are rune but s[i] is byte, causing type mismatch.

2. Step 2: Understand why this is an error

   Go does not automatically convert byte to rune for map keys, so this causes a compile error.

3. Final Answer:

   Using s[i] as byte instead of rune causes wrong map key type -> Option D

4. Quick Check:

   Byte vs rune key mismatch error [OK]

Hint: Use rune(s[i]) or range loop for correct key type [OK]

Common Mistakes:

• Ignoring byte vs rune difference
• Assuming map auto-converts keys
• Thinking map initialization is wrong

5. Given a string, how can you find the character with the highest frequency using Go maps?

hard

A. Use a slice to store counts and pick the last element

B. Count frequencies in a map, then iterate map to find max count character

C. Sort the string and pick the first character

D. Print the string length as the highest frequency

Solution

1. Step 1: Count character frequencies using a map

   Use a map[rune]int to count how many times each character appears.

2. Step 2: Iterate the map to find the character with the highest count

   Loop through the map keys and values, track the max count and corresponding character.

3. Final Answer:

   Count frequencies in a map, then iterate map to find max count character -> Option B

4. Quick Check:

   Map count + max search = highest frequency char [OK]

Hint: Use map to count, then find max by iteration [OK]

Common Mistakes:

• Sorting string does not give frequency
• Using slice without mapping chars
• Confusing length with frequency