Anagram Check Techniques in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Sorting-Based Anagram Check

What is the output of this C# code that checks if two strings are anagrams by sorting?

DSA C#

using System;
using System.Linq;

class Program {
    static void Main() {
        string s1 = "listen";
        string s2 = "silent";
        bool result = s1.OrderBy(c => c).SequenceEqual(s2.OrderBy(c => c));
        Console.WriteLine(result);
    }
}

A Compilation error

B False

C True

D Runtime exception

💡 Hint

Sorting both strings and comparing sequences checks if they have the same characters.

The code sorts both strings and compares them. Since "listen" and "silent" have the same letters, the result is True.

❓ Predict Output

intermediate

Output of Frequency Count Anagram Check

What does this C# code print when checking if two strings are anagrams using character frequency counts?

DSA C#

using System;
using System.Collections.Generic;

class Program {
    static bool AreAnagrams(string s1, string s2) {
        if (s1.Length != s2.Length) return false;
        var counts = new Dictionary<char, int>();
        foreach (char c in s1) {
            if (counts.ContainsKey(c)) {
                counts[c]++;
            } else {
                counts[c] = 1;
            }
        }
        foreach (char c in s2) {
            if (!counts.ContainsKey(c) || counts[c] == 0) return false;
            counts[c]--;
        }
        return true;
    }
    static void Main() {
        Console.WriteLine(AreAnagrams("triangle", "integral"));
    }
}

A True

B False

C KeyNotFoundException

D Compilation error

💡 Hint

Counting characters in both strings and comparing counts confirms anagrams.

Both strings have the same characters with the same frequency, so the function returns True.

❓ Predict Output

advanced

Output of Anagram Check with Case Sensitivity

What is the output of this C# code that checks if two strings are anagrams considering case sensitivity?

DSA C#

using System;
using System.Linq;

class Program {
    static void Main() {
        string s1 = "Dormitory";
        string s2 = "dirtyroom";
        bool result = s1.OrderBy(c => c).SequenceEqual(s2.OrderBy(c => c));
        Console.WriteLine(result);
    }
}

A True

B False

C Compilation error

D Runtime exception

💡 Hint

Uppercase and lowercase letters have different ASCII codes, affecting sorting.

Because 'D' and 'd' are different characters, the sorted sequences differ, so the result is False.

❓ Predict Output

advanced

Output of Anagram Check Using LINQ GroupBy

What does this C# code print when checking if two strings are anagrams using LINQ GroupBy and counts?

DSA C#

using System;
using System.Linq;

class Program {
    static bool AreAnagrams(string s1, string s2) {
        var g1 = s1.GroupBy(c => c).OrderBy(g => g.Key).Select(g => g.Count());
        var g2 = s2.GroupBy(c => c).OrderBy(g => g.Key).Select(g => g.Count());
        return g1.SequenceEqual(g2);
    }
    static void Main() {
        Console.WriteLine(AreAnagrams("apple", "paper"));
    }
}

A False

B Compilation error

C True

D Runtime exception

💡 Hint

Grouping by character and comparing counts only ignores which characters they are.

The code compares only counts of characters ignoring which characters they belong to, so it returns False for these strings.

🧠 Conceptual

expert

Most Efficient Anagram Check for Large Unicode Strings

Which approach is best for checking anagrams of very large strings containing Unicode characters efficiently in C#?

A Sort both strings and compare sorted results

B Convert strings to lowercase and compare with Contains method

C Use a fixed-size array of 26 for character counts

D Use a Dictionary<char, int> to count frequencies and compare

💡 Hint

Consider Unicode range and memory efficiency for large inputs.

Using a Dictionary handles all Unicode characters efficiently without sorting overhead or fixed-size limitations.

Practice

1. What does it mean if two strings are anagrams of each other?

easy

A. They have the same characters in the same frequency but possibly different order

B. They have the same length but different characters

C. They start with the same letter

D. They contain only vowels

Solution

1. Step 1: Understand the definition of anagrams

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

2. Step 2: Compare the options

   Only They have the same characters in the same frequency but possibly different order correctly describes this property; others describe unrelated conditions.

3. Final Answer:

   They have the same characters in the same frequency but possibly different order -> Option A

4. Quick Check:

   Anagram = Same chars & frequency [OK]

Hint: Anagrams have same letters and counts, order doesn't matter [OK]

Common Mistakes:

• Thinking same length means anagram
• Assuming order must be identical
• Confusing anagrams with substrings

2. Which of the following C# code snippets correctly checks if two strings are anagrams by sorting?

easy

A. return s1.Contains(s2);

B. return s1 == s2;

C. return s1.Length == s2.Length;

D. return string.Concat(s1.OrderBy(c => c)) == string.Concat(s2.OrderBy(c => c));

Solution

1. Step 1: Understand sorting approach for anagrams

   Sorting both strings and comparing them checks if they have the same characters in the same order after sorting.

2. Step 2: Analyze each code snippet

   return string.Concat(s1.OrderBy(c => c)) == string.Concat(s2.OrderBy(c => c)); sorts both strings and compares; this is correct. Options B, C, and D do not check anagram conditions properly.

3. Final Answer:

   return string.Concat(s1.OrderBy(c => c)) == string.Concat(s2.OrderBy(c => c)); -> Option D

4. Quick Check:

   Sort & compare strings = correct anagram check [OK]

Hint: Sort both strings and compare to check anagrams [OK]

Common Mistakes:

• Comparing strings directly without sorting
• Only checking length equality
• Using Contains instead of full comparison

3. What will be the output of the following C# code?

string s1 = "listen";
string s2 = "silent";
bool result = s1.OrderBy(c => c).SequenceEqual(s2.OrderBy(c => c));
Console.WriteLine(result);

medium

A. True

B. False

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Sort both strings and compare sequences

   The code sorts characters of both strings and checks if sequences are equal. "listen" and "silent" are anagrams.

2. Step 2: Evaluate the result of SequenceEqual

   Since sorted characters match, SequenceEqual returns true, so Console.WriteLine prints True.

3. Final Answer:

   True -> Option A

4. Quick Check:

   Sorted anagrams equal = True [OK]

Hint: Sorted anagrams produce true when compared with SequenceEqual [OK]

Common Mistakes:

• Assuming order matters before sorting
• Confusing SequenceEqual with Equals
• Expecting false because strings differ initially

4. Identify the bug in this C# method intended to check anagrams:

bool AreAnagrams(string s1, string s2) {
  if (s1.Length != s2.Length) return false;
  var dict = new Dictionary();
  foreach (var c in s1) {
    dict[c] = dict.ContainsKey(c) ? dict[c] + 1 : 1;
  }
  foreach (var c in s2) {
    if (!dict.ContainsKey(c)) return false;
    dict[c]--;
  }
  return true;
}

medium

A. It does not check string lengths

B. It uses a dictionary instead of array

C. It does not check if counts go below zero

D. It returns false too early

Solution

1. Step 1: Review dictionary count decrement logic

   The method decrements counts for characters in s2 but never checks if count becomes negative, which means extra characters in s2 are not detected.

2. Step 2: Identify missing validation

   Without checking if dict[c] < 0 after decrement, method can wrongly return true when s2 has extra characters.

3. Final Answer:

   It does not check if counts go below zero -> Option C

4. Quick Check:

   Check negative counts after decrement to fix bug [OK]

Hint: Always verify counts don't go negative when decrementing [OK]

Common Mistakes:

• Ignoring negative counts after decrement
• Assuming length check is enough
• Not using dictionary for frequency

5. You want to check if two strings are anagrams ignoring case and spaces. Which approach is best in C#?

hard

A. Count characters without removing spaces

B. Remove spaces, convert to lowercase, then sort and compare

C. Compare strings directly ignoring case

D. Check if lengths are equal ignoring spaces

Solution

1. Step 1: Normalize strings by removing spaces and converting to lowercase

   This ensures spaces and case differences do not affect comparison.

2. Step 2: Sort normalized strings and compare

   Sorting both normalized strings and comparing confirms if they are anagrams ignoring case and spaces.

3. Final Answer:

   Remove spaces, convert to lowercase, then sort and compare -> Option B

4. Quick Check:

   Normalize then sort & compare for case/space insensitive anagram [OK]

Hint: Normalize strings by removing spaces and lowercasing before checking [OK]

Common Mistakes:

• Not removing spaces before comparison
• Ignoring case differences
• Only checking length equality