First Non Repeating Character Using Hash in DSA Go

Mental Model

We count how many times each letter appears, then find the first letter that appears only once.

Analogy: Imagine a classroom where each student raises their hand once for every time they speak. We want to find the first student who raised their hand only once.

string: h -> e -> l -> l -> o -> null
counts: {h:0, e:0, l:0, o:0}
↑start

Dry Run Walkthrough

Input: string: "swiss"

Goal: Find the first character in "swiss" that appears only once

Step 1: Count each character's frequency

counts: {s:3, w:1, i:1}

Why: We need to know how many times each character appears

Step 2: Check characters in order to find first with count 1

string: s -> w -> i -> s -> s -> null
checking s (count=3)

Why: s appears 3 times, so skip

Step 3: Check next character w (count=1)

string: s -> w -> i -> s -> s -> null
checking w (count=1)

Why: w appears once, so this is the first non repeating character

Result:

First non repeating character is 'w'

Annotated Code

DSA Go

package main

import (
	"fmt"
)

func firstNonRepeatingChar(s string) rune {
	counts := make(map[rune]int)

	// Count frequency of each character
	for _, ch := range s {
		counts[ch]++
	}

	// Find first character with count 1
	for _, ch := range s {
		if counts[ch] == 1 {
			return ch
		}
	}

	return 0 // no non repeating character found
}

func main() {
	input := "swiss"
	result := firstNonRepeatingChar(input)
	if result != 0 {
		fmt.Printf("First non repeating character is '%c'\n", result)
	} else {
		fmt.Println("No non repeating character found")
	}
}

counts := make(map[rune]int)

Create map to store frequency counts of characters

for _, ch := range s { counts[ch]++ }

Count how many times each character appears

for _, ch := range s { if counts[ch] == 1 { return ch } }

Find first character with frequency exactly one

Output

First non repeating character is 'w'

Complexity Analysis

Time: O(n) because we scan the string twice: once to count and once to find the first unique character

Space: O(k) where k is number of unique characters, because we store counts in a map

vs Alternative: Compared to checking each character by scanning the string repeatedly (O(n^2)), this hash map approach is much faster

Edge Cases

Empty string

Returns no non repeating character found

DSA Go

return 0 // no non repeating character found

All characters repeating

Returns no non repeating character found

DSA Go

return 0 // no non repeating character found

String with one character

Returns that character as first non repeating

DSA Go

if counts[ch] == 1 { return ch }

When to Use This Pattern

When you need to find the first unique element in a sequence, use a hash map to count frequencies and then scan again to find the first unique one.

Common Mistakes

Mistake: Checking counts while counting characters instead of after counting all
Fix: First count all characters, then in a separate loop find the first with count 1

Summary

Finds the first character in a string that appears only once using a hash map.

Use when you need to identify the earliest unique element efficiently.

Count all frequencies first, then scan again to find the first unique character.

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