Anagram Check Techniques in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to convert the string to lowercase for case-insensitive comparison.

DSA C#

string s1Lower = s1.[1]();

Drag options to blanks, or click blank then click option'

AToUpper

BToLower

CTrim

DReplace

Attempts:

3 left

💡 Hint

Common Mistakes

Using ToUpper instead of ToLower, which also works but is not the chosen method here.

Using Trim which removes spaces but does not change case.

Using ToLower() converts all characters to lowercase, making the comparison case-insensitive.

2fill in blank

medium

Complete the code to sort the characters of the string for comparison.

DSA C#

char[] s1Chars = s1Lower.[1]();
Array.Sort(s1Chars);

Drag options to blanks, or click blank then click option'

AToCharArray

BSplit

COrderBy

DToString

Attempts:

3 left

💡 Hint

Common Mistakes

Using Split which splits by a delimiter and returns a string array, not char array.

Using OrderBy which returns an IEnumerable but not an array.

ToCharArray() converts the string into a character array which can be sorted.

3fill in blank

hard

Fix the error in the comparison of sorted character arrays.

DSA C#

bool areAnagrams = new string(s1Chars).[1](new string(s2Chars));

Drag options to blanks, or click blank then click option'

AEquals

B==

CCompareTo

DContains

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' which does not fit the method syntax here.

Using CompareTo which returns an int, not a bool.

Using Equals compares the content of the strings correctly.

4fill in blank

hard

Fill both blanks to create a dictionary counting characters in the first string.

DSA C#

var charCount = new Dictionary<char, int>();
foreach (char c in s1) {
    if (charCount.[1](c)) {
        charCount[c] [2] 1;
    } else {
        charCount[c] = 1;
    }
}

Drag options to blanks, or click blank then click option'

AContainsKey

B+=

CRemove

DUpdate

Attempts:

3 left

💡 Hint

Common Mistakes

Using Add which causes error if key exists.

Using Remove which deletes keys instead of counting.

ContainsKey checks if the character exists; if yes, increment count by 1.

5fill in blank

hard

Fill all three blanks to check if the second string matches the character counts.

DSA C#

foreach (char c in s2) {
    if (!charCount.[1](c)) {
        return false;
    }
    charCount[c] [2] 1;
    if (charCount[c] [3] 0) {
        charCount.Remove(c);
    }
}

Drag options to blanks, or click blank then click option'

AContainsKey

B-=

C==

D+=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+=' instead of '-=' which increases count incorrectly.

Using '!=' instead of '==' for zero check.

Check if character exists, decrease count by 1, and remove if count reaches zero.

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