Check if Two Strings are Anagrams

This one looks simple. But the interviewer is watching how you think. They want to see if you jump straight to sorting. Or if you spot the faster trick. So let us walk through both. The way you would actually say it out loud in the room.

🔤 The Problem

You get two strings. You have to tell if they are anagrams. Anagram means one string is just a rearrangement of the other. Same letters. Same count of each letter. Only the order is different.

Think of the word “listen” and the word “silent”. Same six letters. Just shuffled around. So they are anagrams.

Input:  s = "listen", t = "silent"
Output: true

Input:  s = "hello", t = "world"
Output: false

One quick check first. If the two strings have different lengths, they can never be anagrams. So you return false right away.

🐢 The Brute Way: Sort Both

The first idea most people say is sorting. Sort the letters of both strings. If they are anagrams, the sorted versions become exactly the same string.

So “listen” sorted becomes “eilnst”. And “silent” sorted also becomes “eilnst”. They match. So the answer is true.

This works. But sorting costs time. Sorting a string of length n takes about O(n log n). That is fine. But we can do better. The interviewer almost always wants the faster one next.

🚀 The Optimal Way: Count the Letters

Here is the smarter idea. We do not need the letters in order. We only need to know how many times each letter appears.

So we keep a small count for every letter. For lowercase English letters there are only 26 of them. So a simple array of size 26 is enough.

The trick is one single pass. While we walk through both strings together, we add one for each letter in the first string and subtract one for each letter in the second string. If the strings are true anagrams, every letter we added also got subtracted. So at the end every count is zero.

If even one count is not zero, the letters did not match up. So they are not anagrams.

Steps to check anagrams by counting:

1. If the two lengths are different, return false.
2. Make a count array of size 26, all set to zero.
3. Walk through both strings together. Add one for the letter from the first string. Subtract one for the letter from the second string.
4. Go through the count array. If any value is not zero, return false.
5. If every value is zero, return true.

#include <stdio.h>
#include <string.h>

// Returns 1 if the two strings are anagrams, else 0
int isAnagram(const char *s, const char *t) {
    if (strlen(s) != strlen(t)) return 0;

    int count[26] = {0};
    for (int i = 0; s[i] != '\0'; i++) {
        count[s[i] - 'a']++;   // add for first string
        count[t[i] - 'a']--;   // subtract for second string
    }

    for (int i = 0; i < 26; i++) {
        if (count[i] != 0) return 0;
    }
    return 1;
}

int main(void) {
    printf("%s\n", isAnagram("listen", "silent") ? "true" : "false");
    printf("%s\n", isAnagram("hello", "world") ? "true" : "false");
    return 0;
}

true
false

#include <iostream>
#include <string>
using namespace std;

// Returns true if the two strings are anagrams
bool isAnagram(const string &s, const string &t) {
    if (s.size() != t.size()) return false;

    int count[26] = {0};
    for (size_t i = 0; i < s.size(); i++) {
        count[s[i] - 'a']++;   // add for first string
        count[t[i] - 'a']--;   // subtract for second string
    }

    for (int i = 0; i < 26; i++) {
        if (count[i] != 0) return false;
    }
    return true;
}

int main() {
    cout << (isAnagram("listen", "silent") ? "true" : "false") << endl;
    cout << (isAnagram("hello", "world") ? "true" : "false") << endl;
    return 0;
}

true
false

public class Anagram {

    // Returns true if the two strings are anagrams
    static boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;

        int[] count = new int[26];
        for (int i = 0; i < s.length(); i++) {
            count[s.charAt(i) - 'a']++;   // add for first string
            count[t.charAt(i) - 'a']--;   // subtract for second string
        }

        for (int c : count) {
            if (c != 0) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isAnagram("listen", "silent"));
        System.out.println(isAnagram("hello", "world"));
    }
}

true
false

def is_anagram(s, t):
    # Different lengths can never be anagrams
    if len(s) != len(t):
        return False

    count = [0] * 26
    for i in range(len(s)):
        count[ord(s[i]) - ord('a')] += 1   # add for first string
        count[ord(t[i]) - ord('a')] -= 1   # subtract for second string

    # If every count is zero, the letters matched up
    return all(c == 0 for c in count)


print(is_anagram("listen", "silent"))
print(is_anagram("hello", "world"))

True
False

// Returns true if the two strings are anagrams
function isAnagram(s, t) {
  if (s.length !== t.length) return false;

  const count = new Array(26).fill(0);
  for (let i = 0; i < s.length; i++) {
    count[s.charCodeAt(i) - 97]++;   // add for first string
    count[t.charCodeAt(i) - 97]--;   // subtract for second string
  }

  return count.every((c) => c === 0);
}

console.log(isAnagram("listen", "silent"));
console.log(isAnagram("hello", "world"));

true
false

⏱️ Time and Space Complexity

The counting way wins because it touches each letter only once. Sorting has to rearrange everything first. So sorting at O(n log n) is slower.

The count array is always size 26, no matter how long the strings are. So we call that space O(1). It does not grow with the input.

🧩 Key Takeaways

• ✅ Anagrams have the same letters with the same count. Only the order changes.
• ✅ First check the lengths. Different length means not an anagram, and you stop early.
• ✅ Sorting both strings works but costs O(n log n) time.
• ✅ Counting letters in one pass is the optimal way at O(n) time and O(1) space.
• ✅ For letters beyond a to z, swap the size 26 array for a hash map.

🚀 What’s Next?

• Check Palindrome String
• Group Anagrams