How do you approach Valid Anagram?

If the two strings have different lengths, they can't be anagrams.

What is the time complexity of Valid Anagram?

Time complexity: O(n) - single pass through each string. Space complexity: O(1) - at most 26 characters in the map.

What are common mistakes on Valid Anagram?

Storing the current value before checking for its complement, which lets an element pair with itself. Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n). Using a plain object as the map when keys may be numbers or __proto__; a real hash-map type keeps key identity intact.

gitGood.dev

← Back to problems

Valid Anagram

EasyAlgorithms

Description

Given two strings `s` and `t`, return `true` if `t` is an anagram of `s`, and `false` otherwise. An **anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.

Example 1

Input: s = "anagram", t = "nagaram"

Output: true

Example 2

Input: s = "rat", t = "car"

Output: false

Constraints

- 1 <= s.length, t.length <= 5 * 10^4 - s and t consist of lowercase English letters.

Valid Anagram: approach, complexity and pitfalls

An easy arrays & hashing problem, graded against 8 test cases (5 of them hidden).

The pattern: Arrays & Hashing

Hash maps and sets to trade memory for time - the most common first instinct in interviews.

Reach for it when you see: "Have I seen this before?", counting occurrences, or an O(n²) scan you want to make O(n).

More Arrays & Hashingproblems →

If you are stuck

Show the 3-step hint ladder

If the two strings have different lengths, they can't be anagrams.
Try counting the frequency of each character in both strings.
You can use a hash map or an array of size 26 (for lowercase letters) to count characters.

The optimal approach

Show the approach: Character Frequency Counting

Count the frequency of each character in both strings using a hash map. If both maps are identical, the strings are anagrams.

An even more efficient approach uses a single map: increment for characters in `s` and decrement for characters in `t`. If all counts end at zero, they are anagrams.

Time: O(n) - single pass through each string
Space: O(1) - at most 26 characters in the map

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Empty string. An empty string is passed, so index reads and any assumption of at least one character are tested.

Common Arrays & Hashing mistakes

These apply to the pattern as a whole, not just this problem.

Storing the current value before checking for its complement, which lets an element pair with itself.
Reaching for a sort to deduplicate when a set does it in one pass - that swap quietly costs you the O(n).
Using a plain object as the map when keys may be numbers or `__proto__`; a real hash-map type keeps key identity intact.