Anagram Check Techniques in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to check if two strings have the same length.

DSA C++

bool areSameLength(const string& s1, const string& s2) {
    return s1.length() [1] s2.length();
}

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

A=

B==

C!=

D<

Attempts:

3 left

💡 Hint

Common Mistakes

Using '=' instead of '==' causes assignment, not comparison.

Using '!=' checks for inequality, not equality.

We use '==' to check if the lengths of both strings are equal.

2fill in blank

medium

Complete the code to sort a string using the standard library.

DSA C++

void sortString(string& s) {
    sort(s.[1](), s.end());
}

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

Abegin

Bstart

Cfirst

Dfront

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'start()' or 'first()' which are not valid string methods.

Using 'front()' returns a character, not an iterator.

The 'begin()' function returns an iterator to the start of the string.

3fill in blank

hard

Fix the error in the code to count character frequencies correctly.

DSA C++

bool areAnagrams(const string& s1, const string& s2) {
    if (s1.length() != s2.length()) return false;
    unordered_map<char, int> freq;
    for (char c : s1) freq[c] += 1;
    for (char c : s2) {
        if (freq[c] == 0) return false;
        freq[c] [1] 1;
    }
    return true;
}

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

A=

B+=

C==

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+=' increases frequency incorrectly.

Using '=' assigns a value instead of modifying.

We subtract 1 from the frequency for each character in the second string.

4fill in blank

hard

Fill both blanks to create a map comprehension that counts characters only if they appear more than once.

DSA C++

unordered_map<char, int> freq = [1];
for (char c : s) {
    freq[c] += 1;
}
for (auto& p : freq) {
    if (p.second [2] 1) {
        cout << p.first << ": " << p.second << endl;
    }
}

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

A{}

B[]

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '[]' which is invalid for map initialization.

Using '<=' which checks for less or equal, not more than one.

We initialize an empty map with '{}', and check if frequency is greater than 1.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that filters characters with frequency greater than zero.

DSA C++

unordered_map<char, int> filtered = [1];
for (auto& p : freq) {
    if (p.second [2] 0) {
        filtered[p.[3]] = p.second;
    }
}

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

A{}

B>

Cfirst

Dsecond

Attempts:

3 left

💡 Hint

Common Mistakes

Using '[]' instead of '{}' for map initialization.

Using 'second' instead of 'first' to access the key.

Initialize empty map '{}', check if frequency > 0, and use 'first' to access the key.

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 only alphabets

Solution

1. Step 1: Understand what an anagram means

   An anagram means two strings contain the same characters with the same frequency, but possibly in different orders.

2. Step 2: Identify the key condition for anagram check

   The key condition is that both strings must have the same characters appearing the same number of times.

3. Final Answer:

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

4. Quick Check:

   Anagram = Same characters & frequency [OK]

Hint: Check character counts match for both strings [OK]

Common Mistakes:

• Only checking string length
• Ignoring character frequency
• Assuming order matters
• Checking only first character

2. Which of the following C++ code snippets correctly sorts a string s to help check an anagram?

easy

A. std::sort(s.begin(), s.end());

B. sort(s, s+length);

C. std::sort(s, s+strlen(s));

D. sort(s.begin(), s.end(), compare);

Solution

1. Step 1: Identify correct sorting syntax for std::string

   For std::string, sorting is done using iterators: s.begin() and s.end().

2. Step 2: Check each option for correctness

   std::sort(s.begin(), s.end()); uses std::sort(s.begin(), s.end()); which is correct. sort(s, s+length); and C use pointer arithmetic which is invalid for std::string. sort(s.begin(), s.end(), compare); uses a comparator but is incomplete without defining it.

3. Final Answer:

   std::sort(s.begin(), s.end()); -> Option A

4. Quick Check:

   Sort string with iterators = std::sort(s.begin(), s.end()) [OK]

Hint: Use s.begin() and s.end() with std::sort for strings [OK]

Common Mistakes:

• Using pointer arithmetic on std::string
• Forgetting std:: namespace
• Using incomplete comparator
• Sorting only part of the string

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

std::string s1 = "listen";
std::string s2 = "silent";
std::sort(s1.begin(), s1.end());
std::sort(s2.begin(), s2.end());
if (s1 == s2) std::cout << "Anagrams";
else std::cout << "Not Anagrams";

medium

A. Not Anagrams

B. Anagrams

C. Compilation Error

D. Runtime Error

Solution

1. Step 1: Sort both strings

   After sorting, s1 becomes "eilnst" and s2 becomes "eilnst".

2. Step 2: Compare sorted strings

   Since both sorted strings are equal, the condition s1 == s2 is true, so it prints "Anagrams".

3. Final Answer:

   Anagrams -> Option B

4. Quick Check:

   Sorted strings equal = Anagrams [OK]

Hint: Sort both strings and compare for equality [OK]

Common Mistakes:

• Not sorting strings before comparison
• Confusing output with original strings
• Assuming order matters
• Ignoring case sensitivity

4. Identify the error in the following C++ code for checking anagrams:

bool areAnagrams(std::string s1, std::string s2) {
    if (s1.length() != s2.length()) return false;
    std::sort(s1.begin(), s1.end());
    std::sort(s2.begin(), s2.end());
    return s1.compare(s2);
}

medium

A. Length check is incorrect

B. Missing header <algorithm> for sort

C. Strings should be passed by reference

D. Using s1.compare(s2) returns int, not bool

Solution

1. Step 1: Understand std::string::compare return type

   The compare function returns 0 if strings are equal, else non-zero integer.

2. Step 2: Check return type of function

   The function returns bool but returns s1.compare(s2) which is int, so it will not return correct boolean value.

3. Final Answer:

   Using s1.compare(s2) returns int, not bool -> Option D

4. Quick Check:

   compare() returns int, need == 0 for bool [OK]

Hint: Use (s1.compare(s2) == 0) to get bool result [OK]

Common Mistakes:

• Returning compare() directly as bool
• Ignoring header includes
• Passing strings by value unnecessarily
• Incorrect length check logic

5. Given two strings, which approach is best to check anagrams efficiently when strings contain only lowercase English letters?

hard

A. Sort both strings and compare

B. Use nested loops to check each character presence

C. Use a frequency array of size 26 to count characters

D. Convert strings to uppercase and compare

Solution

1. Step 1: Analyze sorting approach

   Sorting takes O(n log n) time, which is good but not optimal for fixed character set.

2. Step 2: Analyze frequency array approach

   Using a frequency array of size 26 counts characters in O(n) time, which is faster and uses constant extra space.

3. Step 3: Compare other options

   Nested loops are inefficient O(n^2). Converting case does not check anagram correctness.

4. Final Answer:

   Use a frequency array of size 26 to count characters -> Option C

5. Quick Check:

   Frequency array = O(n) efficient anagram check [OK]

Hint: Count chars with array for O(n) anagram check [OK]

Common Mistakes:

• Using sorting for large strings unnecessarily
• Using nested loops causing slow performance
• Ignoring character set constraints
• Assuming case conversion solves anagram check