Anagram Check Techniques in DSA Go - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Anagram Check Using Sorting

What is the output of this Go code that checks if two strings are anagrams by sorting their characters?

DSA Go

package main

import (
	"fmt"
	"sort"
	"strings"
)

func areAnagrams(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	arr1 := strings.Split(s1, "")
	arr2 := strings.Split(s2, "")
	sort.Strings(arr1)
	sort.Strings(arr2)
	for i := range arr1 {
		if arr1[i] != arr2[i] {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println(areAnagrams("listen", "silent"))
	fmt.Println(areAnagrams("hello", "bello"))
}

A

true
true

B

true
false

C

false
false

D

false
true

💡 Hint

Think about what sorting the characters in both strings does before comparing.

The function sorts both strings' characters and compares them. If they match, they are anagrams.

"listen" and "silent" are anagrams, so true. "hello" and "bello" differ, so false.

❓ Predict Output

intermediate

Output of Anagram Check Using Frequency Map

What is the output of this Go code that checks if two strings are anagrams by counting character frequencies?

DSA Go

package main

import "fmt"

func areAnagrams(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	freq := make(map[rune]int)
	for _, ch := range s1 {
		freq[ch]++
	}
	for _, ch := range s2 {
		freq[ch]--
		if freq[ch] < 0 {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println(areAnagrams("triangle", "integral"))
	fmt.Println(areAnagrams("apple", "papel"))
}

A

true
true

B

false
true

C

true
false

D

false
false

💡 Hint

Check how the frequency map changes with each character from both strings.

The frequency map counts characters in s1 and subtracts counts for s2.

If any count goes below zero, strings are not anagrams.

Both pairs are anagrams, so output is true true.

🧠 Conceptual

advanced

Error Type in Anagram Check with Nil Map

What error will this Go code produce when checking anagrams using a nil map for frequency counting?

DSA Go

package main

import "fmt"

func areAnagrams(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	var freq map[rune]int
	for _, ch := range s1 {
		freq[ch]++
	}
	for _, ch := range s2 {
		freq[ch]--
		if freq[ch] < 0 {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println(areAnagrams("abc", "cab"))
}

A true

B compile error: undefined variable freq

C panic: assignment to entry in nil map

D false

💡 Hint

Think about what happens when you try to write to a map that is not initialized.

The map freq is declared but not initialized, so it is nil.

Writing to a nil map causes a runtime panic with message "assignment to entry in nil map".

❓ Predict Output

advanced

Output of Anagram Check Ignoring Case

What is the output of this Go code that checks if two strings are anagrams ignoring case?

DSA Go

package main

import (
	"fmt"
	"strings"
)

func areAnagrams(s1, s2 string) bool {
	if len(s1) != len(s2) {
		return false
	}
	freq := make(map[rune]int)
	for _, ch := range strings.ToLower(s1) {
		freq[ch]++
	}
	for _, ch := range strings.ToLower(s2) {
		freq[ch]--
		if freq[ch] < 0 {
			return false
		}
	}
	return true
}

func main() {
	fmt.Println(areAnagrams("Dormitory", "DirtyRoom"))
	fmt.Println(areAnagrams("Hello", "Olelh"))
}

A

true
true

B

false
true

C

true
false

D

false
false

💡 Hint

Check how strings.ToLower affects the comparison.

Converting both strings to lowercase makes the comparison case-insensitive.

Both pairs are anagrams ignoring case, so output is true true.

🧠 Conceptual

expert

Time Complexity of Anagram Check Using Frequency Map

What is the time complexity of checking if two strings of length n are anagrams using a frequency map approach in Go?

A O(1) since map operations are constant time

B O(n log n) due to sorting

C O(n^2) because of nested loops

D O(n) because each character is processed a constant number of times

💡 Hint

Consider how many times each character is visited and the cost of map operations.

The frequency map approach processes each character once in both strings, so 2n operations.

Map insertions and lookups are average O(1), so total is O(n).

Practice

1. What is the main idea behind checking if two strings are anagrams?

easy

A. Both strings have the same characters with the same frequency

B. Both strings have the same length only

C. Both strings start with the same character

D. Both strings contain vowels only

Solution

1. Step 1: Understand anagram definition

   Anagrams are words or phrases made by rearranging letters of another, so they must have the same characters with the same counts.

2. Step 2: Compare character frequency

   Checking if two strings have the same frequency of each character confirms if they are anagrams.

3. Final Answer:

   Both strings have the same characters with the same frequency -> Option A

4. Quick Check:

   Character frequency equality = Anagram check [OK]

Hint: Check if sorted strings are equal [OK]

Common Mistakes:

• Only comparing string lengths
• Ignoring character counts
• Checking first characters only

2. Which Go code snippet correctly checks if two strings are anagrams by sorting?

easy

A. sort.Strings([]string{s1, s2}); return s1 == s2

B. s1Sorted := sort.Strings(strings.Split(s1, "")); s2Sorted := sort.Strings(strings.Split(s2, "")); return s1Sorted == s2Sorted

C. s1Sorted := strings.Split(s1, ""); sort.Strings(s1Sorted); s2Sorted := strings.Split(s2, ""); sort.Strings(s2Sorted); return strings.Join(s1Sorted, "") == strings.Join(s2Sorted, "")

D. return s1 == s2

Solution

1. Step 1: Split strings into slices of characters

   Use strings.Split(s, "") to get slice of characters for sorting.

2. Step 2: Sort slices and join back to strings

   Sort each slice with sort.Strings and join with strings.Join to compare sorted strings.

3. Final Answer:

   Splitting, sorting slices, then joining for comparison -> Option C

4. Quick Check:

   Sort slices and join = Correct anagram check [OK]

Hint: Split, sort slices, join, then compare [OK]

Common Mistakes:

• Trying to sort strings directly (not allowed)
• Comparing unsorted strings
• Using sort.Strings on whole string instead of slice

3. What is the output of this Go code snippet?

func areAnagrams(s1, s2 string) bool {
    if len(s1) != len(s2) {
        return false
    }
    count := make(map[rune]int)
    for _, ch := range s1 {
        count[ch]++
    }
    for _, ch := range s2 {
        count[ch]--
        if count[ch] < 0 {
            return false
        }
    }
    return true
}

fmt.Println(areAnagrams("listen", "silent"))
fmt.Println(areAnagrams("hello", "bello"))

medium

A. true false

B. false true

C. true true

D. false false

Solution

1. Step 1: Count characters in first string

   Map counts characters in "listen": l=1, i=1, s=1, t=1, e=1, n=1.

2. Step 2: Decrease counts for second string and check negatives

   For "silent", counts decrease to zero without negatives, so true. For "bello", 'b' not in map or count negative, so false.

3. Final Answer:

   true false -> Option A

4. Quick Check:

   Map count balance = true/false [OK]

Hint: Use map counts to verify character balance [OK]

Common Mistakes:

• Not checking length first
• Not returning false on negative count
• Confusing rune and byte iteration

4. Identify the bug in this Go function that checks anagrams:

func isAnagram(s1, s2 string) bool {
    if len(s1) != len(s2) {
        return false
    }
    count := make(map[rune]int)
    for i := 0; i < len(s1); i++ {
        count[rune(s1[i])]++
        count[rune(s2[i])]--
    }
    for _, v := range count {
        if v != 0 {
            return false
        }
    }
    return true
}

medium

A. Not checking string lengths before counting

B. Using rune conversion on byte indexing may miscount multibyte characters

C. Missing return statement at the end

D. Using map with int keys instead of rune keys

Solution

1. Step 1: Understand rune vs byte indexing in Go strings

   Indexing strings by byte (s1[i]) may split multibyte characters incorrectly, causing wrong rune counts.

2. Step 2: Identify correct iteration method

   Use range over string to get runes properly instead of byte indexing with rune conversion.

3. Final Answer:

   Using rune conversion on byte indexing may miscount multibyte characters -> Option B

4. Quick Check:

   Byte indexing ≠ rune iteration for Unicode [OK]

Hint: Use 'for _, r := range s' to handle runes correctly [OK]

Common Mistakes:

• Assuming byte indexing works for all characters
• Ignoring Unicode multibyte characters
• Not checking map values properly

5. Given a list of strings, which Go approach efficiently groups all anagrams together?

hard

A. Use string length as map key to group strings

B. Compare every pair of strings with nested loops checking character counts

C. Count vowels in each string and group by vowel count

D. Sort each string's characters and use the sorted string as a map key

Solution

1. Step 1: Understand grouping anagrams by sorted keys

   Sorting characters of each string creates a unique key for all anagrams, allowing grouping in a map efficiently.

2. Step 2: Compare with other methods

   Nested loops are slow (O(n²)), length or vowel count grouping is inaccurate for anagrams.

3. Final Answer:

   Sort each string's characters and use the sorted string as a map key -> Option D

4. Quick Check:

   Sorted string keys = efficient anagram grouping [OK]

Hint: Sort strings and group by sorted key [OK]

Common Mistakes:

• Using nested loops causing slow performance
• Grouping by length only misses anagrams
• Grouping by vowels ignores consonants