Anagram Check Techniques in DSA C# - Build from Scratch

Anagram Check Techniques

📖 Scenario: You work in a word game company. You need to check if two words are anagrams. Anagrams are words made by rearranging the letters of another word, like "listen" and "silent".

🎯 Goal: Build a simple program to check if two given words are anagrams using letter counting.

📋 What You'll Learn

Create two string variables with exact words

Create a dictionary to count letters

Write a function to check if two words are anagrams

Print the result as True or False

💡 Why This Matters

🌍 Real World

Checking anagrams is useful in word games, spell checkers, and cryptography.

💼 Career

Understanding dictionaries and string manipulation is important for software developers working with text processing.

1

Create two string variables

Create two string variables called word1 and word2 with values "listen" and "silent" respectively.

DSA C#

# Your code here

Hint

Use string type and assign the exact words.

2

Create a dictionary to count letters

Create a Dictionary<char, int> called letterCount to count letters of word1.

DSA C#

string word1 = "listen";
string word2 = "silent";
// Your code here

Hint

Use Dictionary<char, int> and initialize it.

3

Write a function to check anagrams

Write a function called AreAnagrams that takes two strings s1 and s2 and returns bool. Use Dictionary<char, int> to count letters in s1 and compare with s2.

DSA C#

string word1 = "listen";
string word2 = "silent";
Dictionary letterCount = new Dictionary();

// Your code here

Hint

Use two loops: one to count letters in s1, one to subtract counts using s2. Return true if all counts match.

4

Print the result

Use Console.WriteLine to print the result of AreAnagrams(word1, word2).

DSA C#

string word1 = "listen";
string word2 = "silent";
Dictionary letterCount = new Dictionary();

bool AreAnagrams(string s1, string s2)
{
    if (s1.Length != s2.Length) return false;
    Dictionary count = new Dictionary();
    foreach (char c in s1)
    {
        if (count.ContainsKey(c))
            count[c]++;
        else
            count[c] = 1;
    }
    foreach (char c in s2)
    {
        if (!count.ContainsKey(c)) return false;
        count[c]--;
        if (count[c] < 0) return false;
    }
    return true;
}

// Your code here

Hint

Call Console.WriteLine with AreAnagrams(word1, word2) to print the result.

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