The problems I did manage to complete were:

If you want to take a look at my solutions, you can find my code here:

I’m following this strategy every time I start working on a problem.

1. I time myself for 60 minutes using a Pomodoro timer - https://pomodorokitty.com/

2. I create a function signature and use python doc strings to

   • restate the problem

   • come up with example inputs/outputs

   • identify edge cases

   • pseudocode my approach

   • draw out any data structures I will use during my problem

def group_anagrams(strs: list[str]) -> list[list[str]]:
    """
    Given an array of strings, group the anagrams together
    and return a 2D array of the grouped anagrams.

    Example:
    Input: strs = ["eat","tea","tan","ate","nat","bat"]
    Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

    Edge Cases: 
    - Can there be an empty string?
    - Can there be strings with only one character?
    - Can there be the same string repeated?
    - Can there be null strings?
    - Can the strings have trailing spaces?
    - What to return if there are no anagrams?

    Approach:
    - Create a dictionarty to store the anagrams
    - Iterate through the strings and sort the characters in each string
    - If the sorted string is not in the dictionary, add it as a key and the original string as a value
    - If the sorted string is in the dictionary, add the original string to the value list
    - Return the values of the dictionary as a list of lists

    Sample anagrams for following input: ["eat","tea","tan","ate","nat","bat"]
    {
        "aet": ["eat","tea","ate"],
        "ant": ["tan","nat"],
        "abt": ["bat"]
    }
    """
    pass

3. After writing out the pseudocode, I actually code out my solution and add test cases using Python’s doctest library

4. As I wrap up my solution I add comments and discus Time and Space complexity of my solution

5. If I come up with a more optimal solution, I’d update my code and then again discuss the optimizations

def group_anagrams(strs: list[str]) -> list[list[str]]:
    """
    Given an array of strings, group the anagrams together
    and return a 2D array of the grouped anagrams.

    Example:
    Input: strs = ["eat","tea","tan","ate","nat","bat"]
    Output: [["bat"],["nat","tan"],["ate","eat","tea"]]

    Edge Cases: 
    - Can there be an empty string?
    - Can there be strings with only one character?
    - Can there be the same string repeated?
    - Can there be null strings?
    - Can the strings have trailing spaces?
    - What to return if there are no anagrams?

    Approach:
    - Create a dictionarty to store the anagrams
    - Iterate through the strings and sort the characters in each string
    - If the sorted string is not in the dictionary, add it as a key and the original string as a value
    - If the sorted string is in the dictionary, add the original string to the value list
    - Return the values of the dictionary as a list of lists

    >>> group_anagrams(["eat","tea","tan","ate","nat","bat"])
    [['ate', 'eat', 'tea'], ['bat'], ['nat', 'tan']]

    >>> group_anagrams(["x"])
    [['x']]

    >>> group_anagrams(["",""])
    [['', '']]

    >>> group_anagrams(["act","pots","tops","cat","stop","hat"])
    [['act', 'cat'], ['hat'], ['pots', 'stop', 'tops']]

    Sample anagrams for following input: ["eat","tea","tan","ate","nat","bat"]
    {
        "aet": ["eat","tea","ate"],
        "ant": ["tan","nat"],
        "abt": ["bat"]
    }
    """
    anagrams = {}
    for string in strs:
        sorted_string = ''.join(sorted(string))
        if sorted_string in anagrams: 
            anagrams[sorted_string].append(string)
        else:
            anagrams[sorted_string] = [string]

    # Sort each group and then sort the list of groups for consistent output
    result = [sorted(group) for group in anagrams.values()]
    result.sort()
    return result

# Time complexity: O(n * k log k) - n is the number of strings, k is the length of the longest string
# Space complexity: O(n * k) - storing the strings in the dictionary

if __name__ == "__main__":
    import doctest
    if doctest.testmod().failed == 0:
        print("\n** ALL TESTS PASSED. AWESOME WORK! **\n")

Although I haven't participated in many coding interviews, I've gained valuable insights from several informational interviews with senior engineers. A significant aspect of the interview process is evaluating how candidates solve problems and articulate their strategies. This involves gathering requirements and identifying edge cases, much like the tasks we perform as software engineers.

I believe I'm starting to grasp the process, and I plan to practice thinking out loud, even if it feels a bit awkward. The more I practice verbalizing my thoughts while tackling these problems, the more natural it will become.

💡 Key Takeaways

• Dictionaries (hashmaps) reduce time complexity when you need constant-time lookups. They’re game-changers for frequency counts, index tracking, and pairing values (e.g., Two Sum).

• Sorting isn’t always the most optimal solution. While it can simplify some problems (like grouping anagrams), it adds O(n log n) time, which isn’t ideal if you can solve it in O(n) using hashing.

• Think about what data structure gives you the fastest access. If you’re looping + checking something frequently, ask: “Can I store this in a set or dict instead?”

• Start with brute force, then optimize. Sometimes writing the naive solution first helps you identify bottlenecks before jumping to hashmap/set optimizations.

I still catch myself second-guessing every answer, but I’m trying to focus on consistency over perfection. One problem a day is more progress than no problems a week.

But with the current tech landscape being what it is — competitive, unpredictable, and full of “just one more round” interview loops — I know it’s time to face this challenge head-on. No more excuses. I’m committed to giving this prep journey everything I’ve got.

So, I’m kicking off this blog series for three reasons:

1. Accountability: Writing about my journey makes it real.

2. Knowledge Sharing: If I find something that works (or definitely doesn’t), I want to pass it on.

3. Community: Maybe you’re in the same boat — if so, let’s prep together.

🔄 What I’m Starting With

To begin, I’ll be working through the NeetCode 150 problems. These are categorized by topic and difficulty, and they’ve become a go-to roadmap for interview prep across the board.

As I go, I’ll be documenting my progress, problem-solving strategies, and aha! moments here on the blog and across my social platforms. I’ll also share breakdowns of any particularly tricky problems, either in writing or as short-form videos (because explaining it to others helps me lock it in).

🛣️ My Technical Interview Prep Roadmap

This roadmap isn’t rigid, but it gives me structure and a sense of pace. I’m aiming for ~5–10 problems per week depending on the difficulty and topic.

🧠 Months 1–2: Master the Basics

• Arrays & HashTables

• Two Pointers

• Sliding Window

• Stack & Queue

🌱 Months 3–4: Core Data Structures

• Linked Lists

• Binary Search

• Trees & Binary Search Trees

• Heaps & Priority Queues

• Graphs & Traversals

🧩 Month 5: Advanced Topics

• Recursion & Backtracking

• Dynamic Programming

• Tries & Greedy Algorithms

🧱 Month 6: System Design + Mock Interviews

• Scalable architecture concepts

• Real-world design challenges

• Whiteboard-style mock interviews

• Behavioral & STAR method prep

🎯 My Goals & Learning Style

My goal is to be confident and technically sharp enough to apply to senior-level roles at companies like Google, Airbnb, or Netflix by the end of the year. I’m focusing on Python as my interview language, but will revisit JavaScript if needed for front-end roles.

I tend to learn best when I:

• Write things down by hand

• Teach the concept (through a post or a short video)

• Solve problems in batches (with breaks to avoid burnout)

So if you see a post from me explaining a concept, know that it’s as much for me as it is for you!

📚 Resources Page

I’ll be compiling all the tools, courses, cheat sheets, and videos I use on my Resources page, which I’ll update regularly. So if you’re looking for Python templates, Big O cheat sheets, or a sanity-saving visual explanation of dynamic programming, check there first.

✨ Let’s Do This Together

If you’ve been putting this off too — whether because of burnout, fear, or just life — I see you. It’s easy to feel overwhelmed or “behind,” but the truth is, the best time to start was yesterday… and the second-best time is today.

Let’s prep together. 💻

Let’s grow together. 🌱

And let’s land that next dream job. 💼

I’ll be posting updates weekly here and on @ChicanaCodes — feel free to follow along or drop a comment to say hi. If you’re on the same journey, I’d love to cheer you on too.