The Day I Realized I Was a Noob Dev: Lessons from an Anagram Mistake
Tags: programming, beginners, python, productivity
Published: 2024-02-22 11:32:53

Every programmer has their moments of humility, and I had mine on a day when I thought I had it all figured out. It all started with a seemingly simple programming problem - checking if two strings were anagrams. Little did I know that this challenge would reveal just how much I had to learn.
**The Problem That Fooled Me**
The problem was straightforward: `Given two strings, s and t, determine if t is an anagram of s`. 
An anagram, as we all know, is a word or phrase formed by rearranging the letters of another word or phrase, typically using all the original letters exactly once. Piece of cake, right?

Here's the question in its entirety:
[LeetCode link to the problem](https://leetcode.com/problems/valid-anagram/)
```python
'''
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, typically 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 * 104
s and t consist of lowercase English letters.

'''
```
**My Initial Solution**
I dived into the problem headfirst, convinced that I could conquer it effortlessly. My initial solution? Compare the two strings character by character and return `True` if they were the same length. Simple enough, or so I thought:

```python
def anagram(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False

    data_t = {}
    data_s = {}

    for i in s:
        data_s[i] = i
    for f in t:
        data_t[f] = f

    return data_s == data_t
```
**The "Aha! 😒" Moment**

I ran my code, and it seemed to work for some test cases. I felt a sense of accomplishment. But then reality hit me like a ton of bricks. What about the characters' counts? An anagram isn't just about having the same characters; it's about having the same characters in the same quantities.

**The Big Mistake**

My "brilliant" solution had completely overlooked this crucial aspect. I realized that my code would incorrectly declare strings like "rat" and "car" as anagrams simply because they contained the same characters.

![LeetCode anagram challenge](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ii21zhs069fv3fufa3ay.png)

I had rushed into solving the problem without fully understanding its requirements. But there's no shame in making mistakes; the real shame is not learning from them.
The Revised Solution

I knew I had to fix my code. I learned about the importance of character counts in anagrams and came up with a revised solution that properly addressed this aspect.
```python
def anagram(s: str, t: str) -> bool:
    if len(s) != len(t):
        return False

    char_count = {}

    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1

    for char in t:
        if char in char_count:
            char_count[char] -= 1
            if char_count[char] < 0:
                return False
        else:
            return False

    return True
```
**Lesson**
`never underestimate the importance of understanding the problem fully`


Go ahead and tell me about the day you knew that you had to work on you programming skills.