First Non Repeating Character Using Hash in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of First Non Repeating Character Index

What is the output of the following Go code that finds the index of the first non-repeating character in the string?

DSA Go

package main
import "fmt"
func firstNonRepeatingChar(s string) int {
    count := make(map[rune]int)
    for _, ch := range s {
        count[ch]++
    }
    for i, ch := range s {
        if count[ch] == 1 {
            return i
        }
    }
    return -1
}
func main() {
    fmt.Println(firstNonRepeatingChar("swiss"))
}

A 0

B 1

C 3

D -1

💡 Hint

Check the frequency of each character and find the first with count 1.

The string "swiss" has characters: s(0), w(1), i(2), s(3), s(4). Counts: s=3, w=1, i=1.

The code counts frequencies first, then iterates through the string, finding 'w' at index 1 has count 1, so returns 1.

❓ Predict Output

intermediate

Output of First Non Repeating Character Index with No Unique

What is the output of the following Go code when the input string has no non-repeating characters?

DSA Go

package main
import "fmt"
func firstNonRepeatingChar(s string) int {
    count := make(map[rune]int)
    for _, ch := range s {
        count[ch]++
    }
    for i, ch := range s {
        if count[ch] == 1 {
            return i
        }
    }
    return -1
}
func main() {
    fmt.Println(firstNonRepeatingChar("aabbcc"))
}

A 6

B 0

C 1

D -1

💡 Hint

If no character appears once, the function returns -1.

All characters in "aabbcc" appear twice, so no non-repeating character exists.

The function returns -1 in this case.

🔧 Debug

advanced

Identify the Error in First Non Repeating Character Code

What error will the following Go code produce when run?

DSA Go

package main
import "fmt"
func firstNonRepeatingChar(s string) int {
    count := make(map[int]int)
    for _, ch := range s {
        count[ch]++
    }
    for i, ch := range s {
        if count[ch] == 1 {
            return i
        }
    }
    return -1
}
func main() {
    fmt.Println(firstNonRepeatingChar("hello"))
}

A Output: 0

B Runtime panic: invalid memory address or nil pointer dereference

C Compilation error: cannot use rune as int key in map

D Output: 2

💡 Hint

Check the map key type and rune usage.

In Go, rune is an alias for int32, but the map is map[int]int. int and int32 are different types, so count[ch] (ch rune) causes a compilation error: cannot use rune (type int32) as type int in map index.

❓ Predict Output

advanced

Output of First Non Repeating Character with Unicode

What is the output of the following Go code when the input string contains Unicode characters?

DSA Go

package main
import "fmt"
func firstNonRepeatingChar(s string) int {
    count := make(map[rune]int)
    for _, ch := range s {
        count[ch]++
    }
    for i, ch := range s {
        if count[ch] == 1 {
            return i
        }
    }
    return -1
}
func main() {
    fmt.Println(firstNonRepeatingChar("aáa"))
}

A 1

B 2

C -1

D 0

💡 Hint

Unicode characters are handled as runes, each counted separately.

The string "aáa" has characters: 'a' at 0 and 2, 'á' at 1.

'a' appears twice, 'á' once.

The first non-repeating character is 'á' at index 1.

🚀 Application

expert

Number of Unique Non-Repeating Characters

Given the function below, what is the number of unique characters that appear exactly once in the string "abracadabra"?

DSA Go

package main
import "fmt"
func countUniqueNonRepeating(s string) int {
    count := make(map[rune]int)
    for _, ch := range s {
        count[ch]++
    }
    uniqueCount := 0
    for _, v := range count {
        if v == 1 {
            uniqueCount++
        }
    }
    return uniqueCount
}
func main() {
    fmt.Println(countUniqueNonRepeating("abracadabra"))
}

A 2

B 1

C 3

D 4

💡 Hint

Count characters with frequency exactly one.

In "abracadabra", character counts are: a=5, b=2, r=2, c=1, d=1.

Characters 'c' and 'd' appear exactly once.

So the count is 2.

Practice

1. What is the main purpose of using a hash map in finding the first non-repeating character in a string?

easy

A. To count the frequency of each character efficiently

B. To sort the characters alphabetically

C. To reverse the string quickly

D. To store characters in a linked list

Solution

1. Step 1: Understand the role of hash map

   A hash map stores each character as a key and counts how many times it appears in the string.

2. Step 2: Use frequency to find non-repeating character

   By checking the counts, we can find the first character with count 1, which is the first non-repeating character.

3. Final Answer:

   To count the frequency of each character efficiently -> Option A

4. Quick Check:

   Hash map counts characters = frequency count [OK]

Hint: Hash maps count characters fast to find unique ones [OK]

Common Mistakes:

• Thinking hash map sorts characters
• Using hash map to reverse string
• Confusing hash map with linked list

2. Which of the following Go code snippets correctly declares a hash map to store character counts for a string?

easy

A. counts := make(map[string]int)

B. counts := make([]int, len(s))

C. counts := make(map[int]string)

D. counts := make(map[rune]int)

Solution

1. Step 1: Identify correct map key type for characters

   In Go, characters from strings are best represented as 'rune' type, so map[rune]int is correct for counting characters.

2. Step 2: Check other options

   counts := make(map[string]int) uses string as key which is incorrect for single characters; counts := make(map[int]string) reverses key and value types; counts := make([]int, len(s)) is a slice, not a map.

3. Final Answer:

   counts := make(map[rune]int) -> Option D

4. Quick Check:

   Use map[rune]int for character counts in Go [OK]

Hint: Use map[rune]int to count characters in Go strings [OK]

Common Mistakes:

• Using map[string]int for single characters
• Confusing slices with maps
• Using wrong key-value types in map

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

package main
import "fmt"
func main() {
    s := "swiss"
    counts := make(map[rune]int)
    for _, ch := range s {
        counts[ch]++
    }
    for _, ch := range s {
        if counts[ch] == 1 {
            fmt.Println(string(ch))
            break
        }
    }
}

medium

A. w

B. s

C. i

D. No output

Solution

1. Step 1: Count character frequencies in "swiss"

   Characters and counts: 's' = 3, 'w' = 1, 'i' = 1.

2. Step 2: Find first character with count 1 in order

   Order in string: 's'(3), 'w'(1), 'i'(1), 's'(3), 's'(3). First with count 1 is 'w'.

3. Final Answer:

   w -> Option A

4. Quick Check:

   First unique char in "swiss" is 'w' [OK]

Hint: Check counts in string order; first count 1 is answer [OK]

Common Mistakes:

• Picking 's' which repeats
• Choosing 'i' ignoring order
• Expecting no output

4. Identify the bug in this Go code that tries to find the first non-repeating character:

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

medium

A. Loop should use range instead of index

B. Map key should be string, not rune

C. Printing s[i] prints byte, not character

D. Counts map is not initialized

Solution

1. Step 1: Check how character is printed

   Printing s[i] prints a byte as integer, not the character itself.

2. Step 2: Fix printing to convert byte to string

   Use fmt.Println(string(s[i])) to print the character properly.

3. Final Answer:

   Printing s[i] prints byte, not character -> Option C

4. Quick Check:

   Print string(s[i]) to show character, not byte [OK]

Hint: Convert byte to string when printing characters [OK]

Common Mistakes:

• Ignoring printing type mismatch
• Changing map key type unnecessarily
• Not initializing map (already done)

5. Given the string "aabbccdde", which code modification will correctly find the first non-repeating character using a hash map in Go, considering the string may contain Unicode characters?

hard

A. Use map[byte]int and iterate with 'for i := 0; i < len(s); i++'

B. Use map[rune]int and iterate with 'for _, ch := range s' to count frequencies

C. Use map[string]int and split string into substrings of length 2

D. Use map[int]int and convert characters to ASCII codes manually

Solution

1. Step 1: Choose correct map key type for Unicode

   Using map[rune]int allows counting Unicode characters correctly, unlike byte which only handles ASCII.

2. Step 2: Use range loop to iterate runes

   Using 'for _, ch := range s' iterates over runes, correctly handling multi-byte Unicode characters.

3. Final Answer:

   Use map[rune]int and iterate with 'for _, ch := range s' to count frequencies -> Option B

4. Quick Check:

   map[rune]int + range loop handles Unicode correctly [OK]

Hint: Use rune keys and range loop for Unicode-safe counting [OK]

Common Mistakes:

• Using byte keys breaks Unicode characters
• Splitting string incorrectly into substrings
• Using int keys without clear mapping