Solution: Valid Anagram
Tags: algorithms, javascript, leetcode, java
Published: 2021-02-11 19:02:02

*This is part of a series of Leetcode solution explanations ([index](https://dev.to/seanpgallivan/leetcode-solutions-index-57fl)). If you liked this solution or found it useful,* ***please like*** *this post and/or* ***upvote*** *[my solution post on Leetcode's forums](https://leetcode.com/problems/valid-anagram/discuss/1060580).*

---

####[Leetcode Problem #242 (*Easy*): Valid Anagram](https://leetcode.com/problems/valid-anagram/)####

---

***Description:***

*Given two strings `s` and `t`, write a function to determine if `t` is an anagram of `s`.*

---

***Examples:***

Example 1:||
|---:|---|
*Input:*|s = "anagram", t = "nagaram"
*Output:*|true

Example 2:||
|---:|---|
*Input:*|s = "rat", t = "car"
*Output:*|false

---

***Constraints:***
 - You may assume the string contains only lowercase alphabets.

---

***Idea:***

An anagram of a word is basically another word that uses the same letters with the same frequency, just in a different order. Since we only care about the letters and their frequency, the easy choice is to use a **frequency map**.

Since we're dealing with lowercase letters, we can make this more performant by using an Array instead of a more traditional Map, and converting the characters to their unicode number (**97 - 122**) for storage.

First, we iterate through the first string **S** and increment each character code position in our frequency map (**fmap**). Then we run through the second string **T** and decrement the character code positions in **fmap**. If we ever go below **0** then we know we've got a character frequency in **T** that isn't the same as **S**, so we should **return false**.

If we get to the end with no problem, though, we should **return true**.

---

***Implementation:***

In javascript, we can use a typed array **Int16Array** to make the process even more performant.

Python has a string function **count()** that makes this problem even faster.

---

***Javascript Code:***
```javascript
var isAnagram = function(S, T) {
    let len = S.length, fMap = new Int16Array(123)
    if (T.length !== len) return false
    for (let i = 0; i < len; i++)
        fMap[S.charCodeAt(i)]++
    for (let i = 0; i < len; i++)
        if (--fMap[T.charCodeAt(i)] < 0) return false
    return true
};
```

---

***Python Code:***
```python
class Solution:
    def isAnagram(self, S: str, T: str) -> bool:
        SMap = {c: S.count(c) for c in set(S)}
        TMap = {c: T.count(c) for c in set(T)}
        return SMap == TMap
```

---

***Java Code:***
```java
class Solution {
    public boolean isAnagram(String S, String T) {
        int len = S.length();
        int[] fMap = new int[123];
        if (T.length() != len) return false;
        for (int i = 0; i < len; i++)
            fMap[S.codePointAt(i)]++;
        for (int i = 0; i < len; i++)
            if (--fMap[T.codePointAt(i)] < 0) return false;
        return true;
    }
}
```

---

***C++ Code:***
```c++
class Solution {
public:
    bool isAnagram(string S, string T) {
        int len = S.length();
        int fMap [123] = {0};
        if (T.length() != len) return false;
        for (int i = 0; i < len; i++)
            fMap[int(S[i])]++;
        for (int i = 0; i < len; i++)
            if (fMap[int(T[i])]-- == 0) return false;
        return true;
    }
};
```