def balanced_parentheses(self, str):
    count = 0
    for ch in str:
        if ch == '(':
            count += 1
        elif ch == ')':
            count -= 1
    return count == 0

Fix the bug

Put your debugging hat on and test your fix—along with 5 other bugs—right here:
Bugbash Issue #2

Faangshui Lifetime Access with 30% Off

The Lifetime Access to all Faangshui books and guides is on sale at a 30% discount. If you want unlimited access to the Foundations course, interactive lessons, AI feedback, and more for just $69.30, you can grab it here—offer ends soon!

Get Lifetime Premium for $69.30

Happy Bug Fixing!
Nurbo

If you want to follow along with the built-in tasks and see the full guide, please read this guide on the Faangshui platform.

Read on Faangshui

A Simple Example

Suppose we have a large array nums and want to find the sum of the first 10 elements — indices 0 to 9. Think of this subarray as window 1. A window is just a subarray we’re interested in:

sum_of_window1 = 0
for i in range(0, 10):
    sum_of_window1 += nums[i]
print("Sum of window 1:", sum_of_window1)

Now we’re curious about the next window, the subarray from indices 1 to 10 (2nd to 11th elements). We’re moving — or sliding — the window by one element to the right. We could recalculate its sum:

sum_of_window2 = 0
for i in range(1, 11):
    sum_of_window2 += nums[i]
print("Sum of window 2:", sum_of_window2)

But this repeats a lot of work. Notice that window 2 differs from window 1 by just two elements:

• nums[0] is no longer included,

• nums[10] is newly included.

Instead of looping again, we can update in constant time by subtracting the old element and adding the new one:

sum_of_window2 = sum_of_window1 - nums[0] + nums[10]
print("Sum of window 2:", sum_of_window2)

With just one subtraction and one addition, we reuse the previous window’s sum rather than recomputing from scratch. That’s the core of the sliding window approach — taking advantage of what we already know to avoid extra work.

Why Does This Matter?

If we need the sums of the first 100 windows (each of size 10), we can do:

# Calculate the sum of the first window
sum_of_window = 0
for i in range(0, 10):
    sum_of_window += nums[i]
print("Sum of window 1:", sum_of_window)

# Calculate sums of subsequent windows
for window_index in range(1, 100):
    sum_of_window = sum_of_window - nums[window_index - 1] + nums[window_index + 9]
    print("Sum of window", window_index + 1, ":", sum_of_window)

Compare this to recalculating each window from scratch:

for window_index in range(1, 100):
    sum_of_window = 0
    for i in range(window_index, window_index + 10):
        sum_of_window += nums[i]
    print("Sum of window", window_index + 1, ":", sum_of_window)

You save a lot of time by avoiding an extra loop that runs k times (k = window size) for every shift of the window. Instead, you do just two operations per shift.

The essence of the Sliding Windows technique:

1. Find and maintain a subarray (window) of a specific size or condition.

2. Slide the window to the next position by removing the old element(s) and adding the new element(s). Recompute in O(1) or O(log(k)) time rather than O(k) each time.

Use this approach wherever a rolling or continuous data segment is involved—sums, averages, min/max values, counts of distinct elements, and more.

Practice using sliding windows with the task below.

See practice problem

Fixed-Size vs Dynamic Sliding Windows

The fixed-size sliding window is a straightforward application, but often we encounter problems where the window size isn’t fixed but is determined by problem constraints. A classic example is finding the smallest subarray with a sum greater than or equal to a given target.

nums = [2, 1, 5, 2, 3, 2]
target = 7

Multiple subarrays of different sizes meet the condition (e.g., [5, 2], [2, 3, 2]), but we seek the smallest one. A brute-force approach checks all subarrays, taking O(n^2) time—impractical for large arrays.

Dynamic Sliding Window Approach
Instead, let's use a dynamic sliding window in O(n) time. We will use two pointers, left and right, to manage the window’s boundaries, and move through subarrays akin to caterpillars crawling forward.

Expand & Shrink Strategy

• Expand by moving right to the right until current_sum meets or exceeds target.

• Shrink from the left by incrementing left while maintaining the sum condition, tracking the smallest subarray length found.

• Once current_sum is less than target, we can expand again to the right.

left = 0
current_sum = 0
min_length = float('inf')

for right in range(len(nums)):
    current_sum += nums[right]

    # Shrink the window while current_sum >= target
    while current_sum >= target:
        min_length = min(min_length, right - left + 1)
        current_sum -= nums[left]
        left += 1

if min_length == float('inf'):
    print("No subarray found.")
else:
    print("Smallest subarray length:", min_length)

Even though there are nested loops, the time complexity of this approach is O(n), because left and right pointers move through the array only once. The space complexity is O(1), because we are only using a few variables to track the state of the window.

We can summarize the dynamic sliding window approach as follows:

1. Two Pointers (Left & Right):

   • Right pointer extends the window.

   • Left pointer shrinks the window when a condition is exceeded or met.

2. Condition Checks:

   • Could be a sum threshold, a character frequency limit, etc.

   • Move the left pointer whenever the condition is violated or satisfied (depending on problem needs).

3. Track Answer:

   • Continuously update the result (e.g., the shortest window that meets a sum, or the longest window of unique chars).

Sliding windows are a subset of Two Pointers, crucial for problems with variable-size windows. For a deeper dive into Two Pointers, explore the guide on Two Pointers / Index Pointers technique here.

Practice using dynamic sliding windows with the task below to master this powerful technique.

See practice problem

Frequency-Based Sliding Windows

So far, we’ve looked at summation-based sliding windows, where the state of the window is tracked by a single variable (the sum). Another common pattern is frequency-based sliding windows, where we track how many times each element (or character) appears in the window. Some examples include:

• Finding the longest substring with unique characters.

• Locating subarrays that have at most k distinct elements.

• Solving anagrams or frequency-based search problems.

Let's start with a classic example of finding the longest substring with unique characters.

Task: given a string, find the length of the longest substring in which all characters are unique.

For example, given the string "faangfaang", the longest substring with unique characters is "angf", which has a length of 4.

We can solve this with a dynamic sliding window and a set to keep track of the characters in the window. Often you would use a hash map to keep track of the frequency of each character in the window, but in this problem, we only need to know if a character is in the window or not. The general approach is:

1. "Expand" - move the right pointer and add the character to the set.

2. "Shrink" - if the character is already in the set, move the left pointer to the right until the character is no longer in the set.

3. At any moment, after the "Shrink" step, the set will contain only unique characters.

4. When expanding, update the maximum length of the substring with unique characters.

def longest_unique_substring(s):
    char_set = set()
    left = 0
    max_len = 0

    for right in range(len(s)):
        # If the character at 'right' is already in our set,
        # remove chars from the left until it's safe to add the new one
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1

        # Add the new character and update max_len
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)

    return max_len

# Example usage
s = "abcabcbb"
print(longest_unique_substring(s))  # Output: 3 (e.g., "abc")

Frequency-based sliding windows let you handle frequency constraints within a subarray or substring. Notice that similar to summation-based sliding windows, frequency-based sliding windows performs the updates of the state of the window in O(1) time.

Practice using frequency-based sliding windows with the task below.

See frequency-based sliding window task

As always, you can access the full guide with built-in exercises on the Faangshui platform.

Happy Coding!

Nurbo

Try Bugbash Here

What’s Bugbash?

It’s a short coding challenge where you’ll fix bugs in an algorithmic function. Instead of solving big problems from scratch, you’ll spend just a few minutes actively reading and debugging. Why? Because reading code is one of the best ways to sharpen your algorithmic skills—but it can get dull if it’s too passive. Finding bugs keeps it engaging, memorable, and, dare I say, fun.

Try Bugbash Here

How It Works

• Six Bug-Fixing Tasks

  • One Qualifier: This task lets you dip your toes in without pressure.

  • Five Main Tasks: These are the timed challenges that count toward your final score.

• Scoring

  • Your score depends on how fast you squash the bugs and how many failed attempts you make.

  • There’s also a leaderboard so you can see how you stack up against others.

Try Bugbash Here

Why It’s Worth a Try

1. Minimal Time Required
   Each Bugbash challenge should take you only a few minutes—perfect if you’re busy but want a quick mental exercise.

2. Active Code Reading
   You’ll get better at understanding and parsing code by spotting and fixing errors instead of passively reading.

3. Explore Faangshui
   If you haven’t visited the Faangshui platform yet, Bugbash is a fun way to dip your toes in. It’s quick, interactive, and you’ll see what the platform is all about.

Give Bugbash a Go!

Head over to faangshui.com/bugbash to try the first challenge. It’s a small time commitment, but it could make a big difference in your problem-solving skills. Plus, I’d love to hear your thoughts on this new feature—your feedback helps me make the platform better for everyone.

Try Bugbash Here

Take care, and happy bug-hunting!

Nurbo

The term “two pointers” gets mentioned often, but it’s really not a single, one-size-fits-all method. Think of it as a flexible strategy — sometimes you only need one pointer, other times three or more. In this guide, we’ll explore how pointers of all kinds can tackle different challenges, showing that “two pointers” is just the beginning.

I recommend you to follow this guide with embedded practice problems on the new Faangshui platform here.

See the interactive guide on Faangshui

What is a Pointer?

In C, a pointer is a variable that holds the memory address of another variable. For example:

int array[3] = {1, 2, 3};
int *pointer = &array[0];
printf("First element is %d\n", *pointer); // prints 1

*pointer = 10;  // change the first element
printf("Now first element is %d\n", array[0]); // prints 10

pointer++; // move pointer to the next element
printf("Second element is %d\n", *pointer); // prints 2

Because we have the address of an element in an array, we can directly access or modify its value, or shift the pointer itself (pointer arithmetic). This flexibility is what makes pointers powerful.

Index Pointers in High-Level Languages

In higher-level languages like Python or JavaScript, we don’t typically manipulate raw memory addresses. Instead, we store an index that effectively points to an element in an array. Think of RAM as an array of bytes — tracking an index is like using a “pointer” into that array. You can read, modify, or move to other elements by changing the index.

To distinguish from low-level memory address pointers, we’ll call these index pointers. Although pointers can apply to linked lists as well, this guide focuses on index pointers in arrays.

Single Pointer

You’ve likely already used a single pointer without realizing it. A basic example is finding the index of the maximum value in an array:

max_pointer = 0
for i in range(len(nums)):
    if nums[i] > nums[max_pointer]:
        max_pointer = i
print(f"The index of the maximum value is {max_pointer}")

Here, max_pointer stores the index of the currently most interesting element—in this case, the largest value so far. As the loop progresses, this pointer updates whenever a new maximum is found.

Practice Task
Practice using single pointers here.

Practice Single Pointers

Pointers Over Multiple Arrays

Sometimes you’ll need to work with multiple arrays where standard linear traversal isn’t possible because you can’t simply iterate from the beginning to the end of one array. In these cases, you can use multiple single pointers — one for each array.

Example: Merging Two Sorted Arrays
Task: given two sorted arrays, merge them into a single sorted array.

nums1 = [1, 2, 3]
nums2 = [2, 5, 6]
merged_array = [1, 2, 2, 3, 5, 6]

Since you can’t just iterate linearly from start to finish in either array (you don’t know which element is next in sorted order), index pointers are ideal.

Defining the Pointers

• pointer1: Tracks the current position in nums1 — the next element not yet added to merged_array.

• pointer2: Tracks the current position in nums2 — the next element not yet added to merged_array. Initially, both pointers start at index 0 of their respective arrays.

Merging Process

• Compare nums1[pointer1] and nums2[pointer2].

• Whichever element is smaller goes into merged_array, and the corresponding pointer is incremented.

• Repeat until one pointer reaches the end of its array.

• Append any remaining elements from the other array.

pointer1 = 0
pointer2 = 0
merged_array = []

while pointer1 < len(nums1) and pointer2 < len(nums2):
    if nums1[pointer1] < nums2[pointer2]:
        merged_array.append(nums1[pointer1])
        pointer1 += 1
    else:
        merged_array.append(nums2[pointer2])
        pointer2 += 1

# Append remaining elements from nums1 or nums2.
while pointer1 < len(nums1):
    merged_array.append(nums1[pointer1])
    pointer1 += 1

while pointer2 < len(nums2):
    merged_array.append(nums2[pointer2])
    pointer2 += 1

Notice that pointer1 and pointer2 move independently. Each pointer is responsible for tracking progress in its own array.

Practice Task
Practice using pointers over multiple arrays in the task linked here.

Practice Multiple Pointers

Fast and Slow Pointers

Fast and slow pointers are a clever technique for working with arrays or linked structures. They move at different speeds to tackle a range of problems—everything from detecting cycles to in-place array modifications.

Example: Removing Duplicates in a Sorted Array
Task: remove duplicates while keeping all unique elements at the beginning.

slow = 0
for fast in range(1, len(nums)):
    if nums[fast] != nums[slow]:
        slow += 1
        nums[slow] = nums[fast]

How It Works

• Fast pointer: Scans through every element in the array.

• Slow pointer: Keeps track of where the next unique element should be placed.

• Writing unique values: Each time nums[fast] is different from nums[slow], move slow forward and store nums[fast] there.

By the time you finish iterating:

• All unique elements are compacted at the front of the array.

• slow indicates the index of the last unique element.

This approach processes the array in a single pass (O(n) time), making it highly efficient for sorting and deduplication tasks.

Practice Task
Practice using fast and slow pointers in the task linked here.

Practice Fast and Slow Pointers

Converging Pointers

The converging pointers technique places two pointers at opposite ends of an array and moves them toward each other based on specific conditions. It’s commonly used for problems involving comparisons, finding pairs, or narrowing search spaces in a sorted array.

Example: Two-Sum in a Sorted Array
Task: given a sorted array and a target sum, find two numbers that add up to the target.

left = 0
right = len(nums) - 1

while left < right:
    sum = nums[left] + nums[right]
    if sum == target
        return [left, right]
    elif sum < target
        left += 1
    else
        right -= 1

How it works:

1. Initialize pointers: set left at the start and right at the end of the array.

2. Evaluate and adjust:

   • If nums[left] + nums[right] equals the target, the solution is found.

   • If the sum is too small, move left rightward to increase it.

   • If the sum is too large, move right leftward to decrease it.

3. Stop condition: continue until the pointers meet or you’ve found a valid pair.

Because the array is sorted, every pointer adjustment precisely eliminates a chunk of the search space. Each element is examined at most once, resulting in an efficient O(n) solution.

Practice Task
Practice using converging pointers in the task linked here.

Practice Converging Pointers

Role-Based Pointers

Role-Based Pointers is a technique where each pointer has a specific task or role, allowing you to address different parts of a problem at the same time. Unlike other pointer techniques where pointers often depend on one another, in this approach each pointer operates independently based on its assigned role.

Example: Rearranging Even/Odd Elements by Index
Task: rearrange an array so that even indices hold even numbers and odd indices hold odd numbers. Assume the array has an equal number of even and odd elements.

nums = [3, 1, 2, 4]
result = [2, 3, 4, 1]

Solution Using Role-Based Pointers
Let's define two pointers:

• even_idx: Tracks the next even index where an even number should go.

• odd_idx: Tracks the next odd index where an odd number should go.

Here is how the code looks:

even_idx = 0
odd_idx = 1

while even_idx < len(nums) and odd_idx < len(nums):
    if nums[even_idx] % 2 == 0:
        even_idx += 2  # Even number is in the correct position
    elif nums[odd_idx] % 2 == 1:
        odd_idx += 2  # Odd number is in the correct position
    else:
        swap(nums[even_idx], nums[odd_idx])

Each pointer has a specific role:

• even_idx: Ensures even numbers are at even indices, moving forward only when the condition is met.

• odd_idx: Ensures odd numbers are at odd indices, moving forward only when the condition is met. If each pointer finds a number at the wrong index, a swap corrects both simultaneously.

By assigning each pointer its own job, this problem becomes a series of straightforward checks and swaps rather than a single pointer juggling multiple conditions.

Practice Task
Practice using role-based pointers in the task linked here.

Practice Role-Based Pointers

Binary Search

Yes, you read that right — binary search can be seen as an index pointers problem. It’s an algorithm that uses pointers (indexes) to locate a target value in a sorted array efficiently. These pointers mark the boundaries of the search space, and at each step, you check the midpoint to decide which half of the array to explore next.

Intuition behind binary search
Imagine searching for a specific page in a book:

• Open roughly in the middle.

• Check if the target page is earlier or later than where you opened.

• Move left or right, halving the search area until you find the page. Binary search applies this same strategy to an array, repeatedly dividing the problem space in half.

Example: Finding an Element in a Sorted Array
Task: find the index of 7 in the sorted array nums = [2, 4, 7, 10, 14, 15, 17, 29, 45].

1. Start with two pointers:

   • low = 0 (the first index).

   • high = len(nums) - 1 = 8 (the last index).

2. Calculate the midpoint:

   • mid = (low + high) // 2 = (0 + 8) // 2 = 4.

3. Check if nums[mid] is the target:

   • nums[4] = 14, which is not the target.

4. Narrow down the search space:

   • Since 7 is less than 14, we know it must be in the left half.

   • Update high = mid - 1 = 4 - 1 = 3.

5. Calculate the new midpoint:

   • mid = (low + high) // 2 = (0 + 3) // 2 = 1.

6. Check if nums[mid] is the target:

   • nums[1] = 4, which is not the target.

7. Narrow down the search space:

   • Since 7 is greater than 4, we know it must be in the right half.

   • Update low = mid + 1 = 1 + 1 = 2.

8. Calculate the new midpoint:

   • mid = (low + high) // 2 = (2 + 3) // 2 = 2.

9. Check if nums[mid] is the target:

   • nums[2] = 7, which is the target.

10. Return the index of the target:

    • The index of 7 is 2.

This is a simple example, but binary search can handle much larger arrays and more complex search conditions. Putting it into code, you get:

low = 0
high = len(nums) - 1

while low <= high:
    mid = (low + high) // 2
    if nums[mid] == target:
        return mid
    elif nums[mid] < target:
        low = mid + 1
    else:
        high = mid - 1

return -1  # Target not found

Variations of Binary Search
Many versions of binary search exist, such as:

• Lower bound / upper bound: find the first or last position of a value.

• Search insert position: identify where a target should be inserted if not present.

• Rotated array search: adaptations for arrays rotated around a pivot.

Binary search’s power lies in its logarithmic time complexity, making it efficient for large datasets. Give it a try in the practice task linked here to sharpen your skills.

Practice Pointers in Binary Search

Two Pointers Summary

Throughout this guide, we explored how index pointers can efficiently solve an array of problems by focusing on specific positions, traversing arrays in custom orders, or using multiple pointers to handle different tasks. Here are the key takeaways:

1. Indices Are Just Numbers
Think of indices as ordinary integers stored in variables. You can add, subtract, or otherwise manipulate them. When you use these index variables to navigate an array, they effectively act as pointers.

2. Track Important Positions
In many problems, certain positions in an array matter more than others. By assigning pointers to track these positions, you can isolate, modify, or compare them as needed, all within a single pass or minimal passes over the data.

3. Custom Traversals
You’re not restricted to a simple for-loop from start to finish. Index pointers let you move through the array in any order, skipping or revisiting elements based on problem-specific logic.

4. Beyond Arrays
While we focused on arrays, the same pointer logic can apply to linked lists, strings, or even trees. Anywhere you deal with references or indices, pointer-based approaches can shine.

5. Sorted Order is a Hint
Though not mandatory, a sorted array often suggests that pointers can solve the problem. Even if an array isn’t sorted initially, you can sort it first and then apply two-pointer methods for more efficient solutions.

By keeping these principles in mind, you’ll be able to recognize where pointers can simplify your solutions and optimize your algorithms, whether you’re dealing with arrays, lists, or other data structures.

Check out the practice tasks on index pointers to sharpen your skills: Index Pointers / Two Pointers Practice Problems

See the interactive guide on Faangshui

Happy coding,

Nurbo

It's been a while since my last update. Tomorrow, I'll send you an article on the Two Pointers (or dynamic pointers) technique. But today, I wanted to share what I’ve been working on: The Faangshui platform at faangshui.com and the first interactive book on the platform, called Foundations.

Check out Faangshui

Why I Created the Platform

The idea behind Faangshui is simple: make coding interview prep accessible and fun. I like Leetcode, and I enjoy books like CLRS, but I believe there's a way to make learning algorithmic problem-solving even more engaging.

What Makes It Fun?

Quest-Like Structure

The course is designed as a journey, complete with interactive story elements to keep you motivated.

The Story: A digital plague has thrown your village into chaos. Desperate for a solution, the elders send you to the legendary Faangshui Temple. Can you master the algorithms and techniques needed to restore the systems and save your home?

Progressing through the book is like moving through chapters of an epic quest, with each solved problem bringing you closer to saving your village.

Inline Code Editor

Test your solutions immediately after reading the theory. Theory and practice in one place!

151+ Progressive Problems

Problems grow in difficulty at a manageable pace, helping you steadily build confidence and skills. I’m adding more problems every day.

Beginner-Friendly, Yet Engaging for Intermediates

Even if you have some Leetcode experience, you’ll find challenges that deepen your problem-solving capabilities.

AI Feedback from the Faangshui Spirit

Get automated, helpful commentary on your code as you go—making the learning process more interactive and insightful.

I’m not entirely sure if I achieved everything I set out to do—you tell me!

Check out Faangshui

Who’s It For?

Foundations is the course you should take before diving into Leetcode, or if you’re currently struggling with the so-called “Easy” problems. The goal is to help you build your algorithmic problem-solving skills (APSS) so you can tackle any algorithm or data structure with confidence.

Topics Covered:

• Accumulators

• Loops

• Indexing

• Dynamic Pointers (Two Pointers)

• Sliding Windows

• Counters

• Hash Tables

More advanced topics are on the way, and I plan to publish new lessons every week!

Check It Out!

I’d love your feedback on both the Faangshui platform and the Foundations book. Your insights help me improve the learning experience for everyone.

Stay tuned for tomorrow’s article on the Two Pointers technique (a.k.a. dynamic pointers). In the meantime, feel free to explore faangshui.com and let me know what you think!

Check out Faangshui

Happy Coding,

Nurbo

To excel in communication during your interview, you don't have to be an extrovert or pretend to be overly friendly. There are two key components to effective communication during interviews:

1. Keep the interviewer informed.

2. Listen to and acknowledge interviewer feedback.

Subscribe now

Keep the Interviewer Informed

At any moment, the interviewer should know what you're doing. You don't have to talk constantly unless you want to. What's important is to tell the interviewer what you plan to do next, especially during transitions—moments when you start doing something new.

Here is a list of common transitions with example phrases you could use:

1. After the Interviewer Presents You the Problem

"Alright, let me reread the problem description to see if I have any questions."

2. After You Fully Understand the Problem and Need Time to Think

"I think I understand the problem now. Let me think about possible approaches."

3. After You Have Explained Your Approach

"Does this sound reasonable to you?"

4. Before Starting Implementation

"I'd like to start implementing this unless you'd like me to explore further optimizations."

5. During Major Sections of Coding

For every significant section of code, briefly explain what you're doing. There's no need to comment on every line—you can keep quiet while you're coding.

• "First, I'll count the occurrences of these words in the text."

• "Here, I'm going to implement a helper function to check if the state is valid."

6. If You Get Stuck at Any Point

If you're unsure about something, express your thoughts aloud.

• "I'm thinking about whether there's a better way to implement this function."

• "Perhaps it would be easier to use a hash set here instead of a hash table."

7. After Finishing Coding—Don't Just Say "I'm Done"

Testing is crucial. Begin with a quick code review.

"Alright, let me quickly walk through the code to make sure I haven't missed anything."

8. Testing the Code with a Real Example

After the quick check and fixing any obvious bugs, test your code with an actual input.

"Now, let me test the code with this input to make sure it works as intended."

9. While Running the Input

Narrate the key steps your code is performing. Focus on important variables and state changes, not every single line. Don’t forget — you are testing this for yourself, not for the interviewer.

• "Here, the array is initialized with zeroes."

• "Because the condition is satisfied, we'll exit the loop and return the result."

10. After Thoroughly Checking Your Code

"I think this code should work."

If you keep quiet, the interviewer might feel that you're struggling. If they do, they may provide unnecessary help, which could negatively affect your interview assessment. To avoid confusion, communicate with the interviewer when it's important to do so.

Listen for Feedback

There may be moments when the interviewer notices you're heading down the wrong path. They might tell you directly or indirectly, while you're explaining your approach or implementing your solution. In these moments, don't dismiss the interviewer's feedback. Take the time to understand their concern and then either:

1. Politely Acknowledge if You Already Had a Plan to Address It

"Ah, I see your point. I'll address that separately."

2. Admit and Fix the Issue

"Thanks for the pointer! Let me think about how I can fix this..."

Interviewers rarely interrupt unless there's a real issue in your approach or code. Show the interviewer that you can receive feedback and resolve potential issues sooner rather than later.

Final Thoughts

Effective communication during a coding interview doesn't mean you have to be overly talkative or extroverted. By keeping the interviewer informed and actively listening to their feedback, you demonstrate professionalism, confidence, and the ability to collaborate—qualities highly valued in a software engineer.

Remember, the goal is to make the interview a smooth experience for both you and the interviewer. Clear communication helps prevent misunderstandings and showcases your problem-solving process, increasing your chances of success.

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

There's a smarter way to leverage Leetcode in your preparation, and it involves combining foundational skills with the power of ChatGPT.

Before You Dive into Leetcode

Before jumping into Leetcode problems, it's crucial to build your foundational Algorithmic Problem-Solving Skills (APSS). This doesn't require deep knowledge of algorithms and data structures beyond basic constructs like loops, arrays, conditionals, and perhaps hash tables.

Focusing on strengthening your APSS ensures that you can approach problems logically and creatively, setting a solid foundation for learning more advanced topics later on. You can find a list of problems to build your foundational APSS in the article below.

Leveraging ChatGPT + Leetcode

Once you've established a strong foundation in APSS, it's time to dive into theory and practice. Here's how you can effectively use ChatGPT alongside Leetcode to optimize your preparation.

Step 1: Learn the Theory with ChatGPT

Use ChatGPT to learn and understand key concepts in algorithms and data structures.

Example Prompt:

"I'm preparing for my coding interviews and I want to learn the stack data structure. Explain this data structure to me as the best teacher in the world would and show me how to use it with a few basic problems."

ChatGPT can provide clear explanations, examples, and answer any follow-up questions you might have. This interactive learning helps solidify your understanding before you tackle actual problems.

Step 2: Get a Curated List of Problems

After grasping the theory, ask ChatGPT to provide a list of Leetcode problems related to the topic.

Example Prompt:

"Give me a list of 10 Leetcode problems of increasing difficulty that must be solved using stacks."

This approach ensures that you're practicing problems directly related to the concept you've just learned, reinforcing your understanding through application.

Solving Problems on Leetcode

Now that you have a tailored list of problems, it's time to put your skills to the test.

Time Management

• Set a Timer: Start the built-in timer on Leetcode.

• Allocate 20 Minutes: Spend up to 20 minutes devising an approach to the problem.

Problem-Solving Approach

• Doodle and Diagram: Sketch out examples and think through the problem visually.

• Relate to Examples: Consider how the problem relates to the examples provided by ChatGPT.

• Identify Patterns: Look for patterns or similarities with problems you've solved before.

When You Get Stuck

If you can't find the right approach after 20 minutes, it's a sign that you may need more practice or that the problem is currently too challenging.

Option 1: Seek Intuition

Prompt ChatGPT for guidance without requesting the full solution.

Example Prompt:

"Explain the intuition for the Leetcode problem 'Evaluate Reverse Polish Notation' without providing any code or the solution."

This helps you gain insights into the problem while still allowing you to work through the solution independently.

Option 2: Adjust the Difficulty

If you've successfully solved a few problems but are struggling with the next one, the difficulty jump might be too steep.

Example Prompt:

"I was able to solve 'Valid Parentheses' and 'Min Stack,' but I'm struggling with 'Largest Rectangle in Histogram.' Can you suggest a couple of other Leetcode problems that are slightly easier but will help me prepare for this one?"

This way, you can progressively build up to more challenging problems.

Achieving Mastery

Continue this process until you can solve at least five consecutive medium-level problems on the topic on your own. This consistency indicates a strong grasp of the topic.

How to Save Time

Once you're comfortable with a topic and have solved several problems independently, you can optimize your practice sessions.

Selective Implementation

• Outline Solutions: For every other problem, read the problem statement and outline your approach without coding.

• Verify with Solutions: Compare your approach with the official solutions or discussions.

• Code When Necessary: If your approach differs or you feel uncertain, take the time to implement the solution.

Note: Only adopt this strategy if you're confident in your coding abilities. If you need to improve your coding skills, it's advisable to implement every solution.

Applying Binary Search to Identify Your Level

After covering all the major topics, it's time to simulate the unpredictability of real interviews.

Step 1: Prepare the List

• Filter Problems: On Leetcode, filter for unsolved medium-level problems.

• Sort by Acceptance Rate (High to Low): This often correlates with difficulty.

Step 2: Binary Search Your Skill Level

• Start in the Middle: There are 1,800 medium problems, begin in the middle on page 9. Pick any problem on the page.

• Assess and Adjust:

  • If You Solve It Easily: Move forward by a few hundred problems (page 14).

  • If You Struggle: Move backward to page 4.

  • Keep doing this until you find your approximate level.

This method helps you find the range of problems that match your current skill level.

Step 3: Focused Practice

Once you've identified your level:

• Solve Problems Down The List: These problems will have slightly lower acceptance rate and are generally considered more difficult.

• Track Your Progress: Aim to solve several problems consecutively to build confidence.

• Skip Ahead If Needed: As you improve, probe ahead and challenge yourself with problems that have even lower acceptance rates.

What About Blind-75 Or Neetcode-150?

These lists are okay, but they are more useful to folks who have already built strong APSS. Mind you, they do not cover all problem types and they don’t necessarily represent the most frequently asked interview problems. They are there just to provide some structure.

I think you are better off just using ChatGPT to create your own custom problem lists.

How Many Problems Should You Solve?

The number varies depending on individual factors like experience and proficiency.

• Minimum Recommendation: Aim to solve at least 10 problems per major topic.

• Quality Over Quantity: It's better to deeply understand and internalize solutions to 150 problems than to superficially attempt 500.

• Personalize Your Goal: Assess your confidence and readiness rather than fixating on a specific number.

Remember: Some may reach readiness after solving 30 problems, especially with prior experience. Others might need more practice, and that's perfectly okay.

Final Thoughts

Preparing for coding interviews is not about the sheer volume of problems you solve but about effective learning and consistent practice. By leveraging tools like ChatGPT and employing strategic approaches to problem-solving, you can make your preparation more efficient and less overwhelming.

Key Takeaways:

• Build a Strong Foundation: Strengthen your APSS before diving into complex problems.

• Use ChatGPT Wisely: It's a valuable resource for learning theory and getting tailored practice problems.

• Practice Efficiently: Focus on understanding rather than rote memorization.

• Assess Your Level: Use binary search on Leetcode to find problems that match your skill level.

• Quality Matters: Deep understanding of fewer problems is more beneficial than a superficial grasp of many.

Request For Topics

The topic of today’s issue was kindly suggested by Atman and the previous one was inspired by a question from Pavel. Kudos to you guys!

If there are questions or topics you want to read about in the next issue, comment below or email me.

As always, you can book a free introductory coaching session with me here.

Stay curious and happy coding!

Nurbo

The Problem: Cycle Detection

First, let's understand the problem the algorithm addresses. The cycle detection problem involves determining whether a linked structure (like a linked list) contains a cycle. In other words, we need to check if there's a way to start from a node and follow a sequence of links that eventually loops back to the same node.

A straightforward solution is to traverse the linked list while keeping track of the nodes we've visited using a hash table (or a set). If we reach a node we've seen before, we know there's a cycle. If we reach the end (a null pointer) without encountering a repeated node, there's no cycle.

This method works fine and has a time complexity of O(N), where N is the number of nodes, but it requires O(N) additional space to store the visited nodes.

Subscribe now

Introducing the Tortoise and Hare Algorithm

The Tortoise and Hare algorithm, also known as Floyd's Cycle Detection Algorithm, offers a way to detect cycles using only constant O(1) space, while maintaining O(N) time complexity.

How It Works

• Two Pointers: We use two pointers to traverse the linked list:

  • Tortoise (Slow Pointer): Moves one node at a time.

  • Hare (Fast Pointer): Moves two nodes at a time.

• Cycle Detection:

  • If there's no cycle: The hare will reach the end of the list (a null pointer) before the tortoise.

  • If there's a cycle: The hare will eventually lap the tortoise, and they will meet at some node within the cycle.

Understanding Why It Works

Intuitive Explanation

Imagine you and a friend are running on a circular track:

• You (Tortoise): Run at a steady pace (one lap per hour).

• Your Friend (Hare): Runs twice as fast (two laps per hour).

If you both start at the same point, your friend will lap you after one hour because they're running twice as fast. Even if you start at different points, your friend will eventually catch up to you because they're moving faster on the same loop.

In the context of a linked list with a cycle, the hare moves through the nodes twice as fast as the tortoise. If there's a cycle, the hare will "lap" the tortoise and they will meet inside the cycle.

Why the Hare Doesn't Overjump the Tortoise

A common question is: Why doesn't the hare skip over the tortoise without meeting it?

Since the hare moves two steps for every one step the tortoise takes, the distance between them decreases by one node on each move:

• If the hare is K nodes behind the tortoise, after each move, the gap reduces by one.

• Eventually, the hare will catch up to the tortoise.

In other words, the speed of the hare relative to the speed of the tortoise, is only one node per iteration. It is as if the tortoise is standing in its place while the hare is moving one node at a time. Because the hare gets closer (in a cycle) or further (without a cycle) only one node at a time, there is no way for the hare to skip over the tortoise.

Where Do They Meet?

If there is a cycle, the tortoise and hare will meet somewhere within the cycle. The exact node where they meet depends on the length of the non-cyclic part of the list and the length of the cycle.

Finding the Start of the Cycle

Once we've detected a cycle (when the tortoise and hare meet), we might want to find the node where the cycle begins.

The Algorithm

1. Reset the Tortoise: Move the tortoise pointer back to the head of the list.

2. Move Both Pointers at the Same Speed: Now, both the tortoise and hare move one step at a time.

3. Point of Intersection: The node where they meet again is the start of the cycle.

Why Does This Work?

Let's break it down mathematically:

• Let:

  • L be the length of the non-cyclic part (nodes before the cycle starts).

  • C be the length of the cycle.

  • M be the distance from the start of the cycle to the point where the tortoise and hare first meet within the cycle.

  

• At the first meeting point:

  • The tortoise has traveled L + M steps.

  • The hare has traveled L + M + N * C steps, where N is the number of full cycles the hare has completed (N ≥ 1).

  • Since the hare moves twice as fast, Hare's distance = 2 * (Tortoise's distance):

2(L + M) = L + M + N * C

• Simplify the equation:

2L + 2M = L + M + N * C
=> (2L - L) + (2M - M) = N * C
=> L + M = N * C

• This means L + M is a multiple of C.

• When we reset the tortoise to the head and move both pointers one step at a time:

  • The tortoise moves L steps to reach the start of the cycle.

  • The hare, starting from the meeting point, will also move L steps (since it's N * C - M, which simplifies to L due to the earlier equation), and they will meet at the cycle's starting node.

Intuitive Explanation

Let M be the distance from the start of the cycle to the point where the tortoise and hare first meet within the cycle. By moving tortoise back to the start, we are kind of resetting the race. But this time, we are giving the hare a head start of exactly M positions. What it means is that now tortoise and hare will meet M positions sooner, which is exactly where the start of the cycle is.

Applications Beyond Linked Lists

The Tortoise and Hare algorithm isn't limited to linked lists. It can be applied to any scenario where we can model the problem as moving through states with possible cycles.

Examples

1. Find the Duplicate Number

Given an array of integers nums containing n + 1 integers where each integer is in the range [1, n] inclusive. There is only one repeated number in nums, return this repeated number.

Constraints:

• You must solve the problem without modifying the array nums and use only constant extra space.

Solution:

• Modeling as a Linked List: Treat the array as a linked list where each index is a node, and the value at each index points to the next node.

• Applying Tortoise and Hare: Use the cycle detection algorithm to find the duplicate number, which corresponds to the start of the cycle.

• LeetCode Problem: Find the Duplicate Number

2. Happy Number

A happy number is a number defined by the following process:

• Starting with any positive integer, replace the number by the sum of the squares of its digits.

• Repeat the process until the number equals 1 (where it will stay), or it loops endlessly in a cycle that does not include 1.

• Those numbers for which this process ends in 1 are happy.

Return true if n is a happy number, and false if not.

Solution:

• Modeling the Process: Each number generated is a state, and we can consider the process as moving from one state to another.

• Applying Tortoise and Hare: Use the algorithm to detect if there's a cycle (which would mean the number is not happy).

• LeetCode Problem: Happy Number

Subscribe now

Is This Algorithm Useful for Interviews?

Yes and No.

Yes:

• Demonstrates Deep Understanding: Knowing the Tortoise and Hare algorithm shows that you have a solid grasp of algorithmic techniques and can apply them to solve problems efficiently with optimal space complexity.

• Useful for Certain Problems: Some interview problems are best solved using this algorithm, especially when space constraints are tight.

No:

• Challenging to Derive on the Spot: Unless you're familiar with the algorithm beforehand, it's unlikely you'll come up with it during an interview under time pressure.

• Acceptable Alternatives: Interviewers generally accept solutions that use hash tables to detect cycles, even if they use O(N) space, as long as the time complexity is acceptable and the solution is correct.

My Recommendation

• Familiarize Yourself: Even if you don’t stumble upon a cycle detection problem or won’t use the algorithm in your solution, it's beneficial to understand this strategy.

• Communicate with the Interviewer: If space complexity is a concern, mention that you know an O(1) space solution using the Tortoise and Hare algorithm.

• Use the Best Approach You Know: If you're unsure about implementing the algorithm correctly, it's better to use a method you're confident with, like using a hash table to track visited nodes.

Conclusion

The Tortoise and Hare algorithm is a clever technique for detecting cycles with constant space complexity. Understanding why it works can deepen your grasp of algorithmic concepts and might give you an edge in interviews.

Remember:

• Cycle Detection: Two pointers moving at different speeds can detect cycles when they meet.

• Finding Cycle Start: Resetting one pointer to the head and moving both at the same speed leads to the cycle's entry point.

• Applications: Beyond linked lists, the algorithm applies to any sequence of states with potential cycles.

Stay curious and happy coding!

Nurbo

Batch Mentorship Session Bookings Available Now

By popular request I just enabled batch-bookings for my mentorship sessions.

If you book 10 sessions at once, you will save $200. Just follow this link to book all 10 sessions or just book the first of the 10 and you can book the rest later.

Build Your APSS

The first thing you need to do is build your Algorithmic Problem-Solving Skills (APSS). This is a skill set that can be trained and doesn't require deep knowledge of algorithms and data structures beyond the basic constructs such as loops, arrays, conditionals, and perhaps hash tables. If your APSS are strong, it's easy to learn new algorithms or data structures as needed. In fact, learning a new algorithm will be similar to working on a new APSS-strengthening exercise. On the other hand, even if you've memorized all the algorithms and data structures, you may struggle to solve a random problem thrown at you during your interview if your APSS are weak.

If this all sounds too cryptic, here is an example of an APSS-strengthening problem that doesn’t require any advanced knowledge:

Example: Print a Spiral Matrix

Write a function that takes an integer n and prints an n x n matrix in spiral order, starting with the number 1 in the top-left corner and ending with n² in the center. The matrix should be filled in a clockwise spiral, incrementing each value by 1 as you go.

For n = 5, the output would be:

 1  2  3  4  5
16 17 18 19  6
15 24 25 20  7
14 23 22 21  8
13 12 11 10  9

As you can see in this problem, there is no advanced algorithm involved. All you need to solve this problem are loops and an array. If your APSS are in shape, you'll be able to devise a solution by carefully simulating the spiral traversal and filling in the numbers accordingly.

Subscribe now

Why Focus on APSS?

• Foundation for Complex Problems and Algorithms: Strong problem-solving skills are the foundation upon which you can build knowledge of advanced algorithms and data structures.

• Adaptability: Interviews often present unique problems. Relying solely on memorized solutions won't help if you can't adapt your thinking to new scenarios.

• Confidence: Developing APSS boosts your confidence in tackling unfamiliar problems, reducing anxiety during interviews.

How to Build Stronger APSS

APSS exercises vary depending on your current level. In general, APSS problems don’t require any more knowledge than you already have. These are stretch exercises that make you more agile with your current knowledge.

For beginners, that usually means problems solvable with just arrays, loops and conditionals. You can later add hash tables and recursion to that list. I have shared a list of APSS-building problems for beginners here:

For more advanced learners, you will naturally strengthen your APSS when solving more and more problems from Leetcode or elsewhere.

Other Problems to Test Your APSS

Here are a few other fun problems that should be suitable for any level:

1. Print a Diamond Pattern

Given a positive odd integer n, print a diamond pattern made of asterisks (*) where the widest point is n asterisks wide.

Input: n = 5

Output:

  *
 ***
*****
 ***
  *

2. Increasing Staircase Pattern

Given an integer n, print a right-justified staircase of numbers that increases with each step. The last row should contain the numbers from 1 to n.

For n = 5, the output would be:

        1
      1 2
    1 2 3
  1 2 3 4
1 2 3 4 5

3. Rearrange Array to Move All Zeros to the End

Problem Statement:

Given a 1D array of integers, rearrange it in-place so that all zeroes are moved to the end while maintaining the order of non-zero elements.

Example: For [0, 1, 0, 3, 12], the output should be [1, 3, 12, 0, 0].

Next Steps

Only after strengthening your APSS do I recommend gradually moving on to classic algorithms and data structures and precompiled lists. With a solid foundation, you'll find it easier to understand and implement more complex concepts.

Remember, it's not about how many problems you've memorized but how well you can apply fundamental concepts to solve new problems.

Stay curious and happy coding!

Nurbo

Subscribe now

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

However, there are also situations where you performed reasonably well, but you're unsure whether you passed the interviews. Often, your interviewers might be on the fence about extending an offer as well.

In these borderline cases, there's a way to tip the scales in your favor, and it has nothing to do with your technical skills. It's all about showing enthusiasm.

Subscribe now

Why Enthusiasm Matters

Enthusiasm can make a significant difference in the hiring decision. It demonstrates your genuine interest in the company and the role, which can be a deciding factor when interviewers are uncertain. Showing that you're eager to join the team and contribute positively can set you apart from other candidates with similar technical abilities.

I've personally sat on a few hiring committees where perhaps one or two interviews didn't go perfectly for a candidate. However, because the candidate showed so much enthusiasm for the company, there were advocates who would say that this person would be a great fit for the team. Others would agree, and we ended up extending an offer. Their passion and eagerness to contribute made a lasting impression that outweighed minor technical shortcomings.

Enthusiasm signals to the interviewers that you are not just looking for any job but are specifically interested in contributing to their company's success. This can make them more willing to invest in you, even if there are areas where you need to grow.

Ways to Show Your Enthusiasm

You don't have to fake passion for the company or offer excessive praise. Showing enthusiasm means demonstrating that you care and are genuinely interested in what the company does. You prove your enthusiasm by doing your homework and learning about the company’s business. Your interest will naturally shine through during your conversations with interviewers.

Here are some effective ways to convey your enthusiasm during the interview process:

1. Research the Company

• Understand the Mission and Values: Familiarize yourself with the company's mission statement and core values. Reflect on how they align with your personal and professional goals.

• Know the Products and Services: Explore the company's products or services. If possible, use them yourself to gain firsthand experience.

• Read the Engineering Blog: If the company has an engineering blog, read recent posts. This can give you insight into their development processes and current projects.

2. Engage with the Industry

• Stay Informed: Keep up with the latest trends and developments in the industry.

• Understand Industry Challenges: Discuss common challenges in the industry and how you might address them, demonstrating critical thinking and initiative.

3. Prepare Thoughtful Questions

• Ask Insightful Questions: Prepare questions that show deep interest, such as inquiries about upcoming projects, team dynamics, or company growth plans.

• Avoid Questions About Tech Stack: These questions don’t tell much about you or the company. You shouldn’t be joining a company for the tools they use, so don’t waste the opportunity to ask meaningful questions.

• Avoid Generic Questions: Steer clear of questions that could be easily answered by reading the company's website.

Summing up

While technical skills are crucial, enthusiasm and cultural fit can play a significant role in the hiring decision, especially when interview performance is borderline. By demonstrating genuine interest and aligning yourself with the company's mission and values, you can boost your chances of receiving an offer.

Remember, showing enthusiasm doesn't cost anything, but it can make all the difference.

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

Many candidates approach this phase without a clear plan. However, you can significantly improve your odds of success by adopting a structured approach.

I call this structure the opening strategy.

Just like in chess, where the opening strategy sets the direction of the game, your interview opening strategy sets the tone for the rest of your interview.

Subscribe now

The Ideal Opening Strategy for Your Coding Interview

Minutes 1–3: Read the Problem Carefully

• Read the problem statement thoroughly.

• Reread important parts to ensure complete comprehension.

Minutes 3–5: Analyze Inputs and Outputs

• Examine the input and output formats.

• Draw diagrams on paper—arrays, trees, graphs, etc. Make sure to have your pen and paper ready for this.

• Check the role of each parameter.

• Verify why the sample output corresponds to the given input.

• Visualize extensively: data structures, data flow, and the actions applied to the data.

Minutes 1–5: Ask Clarifying Questions

• At any point during this time, ask the interviewer clarifying questions.

• Aim to ask at least two meaningful questions.

• Avoid jumping into solutions; suppress thoughts about the approach or implementation for now.

Minutes 5–7: Create Your Own Examples

• Develop one or two examples to verify your understanding.

• Confirm these examples with the interviewer.

• This will help in identifying a viable approach.

Tips for Creating Examples:

• Don't make them too simple or too complex; ensure they have substance.

• Copy and modify the sample input provided if the input is too complex to write from scratch (i.e. matrix, graphs, etc.).

• Consider changing some parameters if there are several for a quick new example.

• Avoid focusing on edge cases at this point.

The goal of the first part of your opening strategy is to fully understand the problem. Understanding the problem is half the solution. If you don't fully grasp what's being asked, it's unproductive to start thinking about solutions. There should be no trace of doubt in your understanding.

Minutes 7–15: Identify an Optimal Approach

Now that you thoroughly understand the problem and have worked through examples, it's time to devise an approach.

• Use your drawings, examples, and prior experience with similar problems to guide you.

• Don't be overly cautious; explore any algorithms or data structures that come to mind.

• Discuss your thought process with the interviewer.

• Aim to find the most efficient solution before diving into coding.

Minutes 15–40: Implement Your Solution

This phase isn't part of the opening strategy, but it greatly benefits from it. If you've executed your opening strategy effectively, this part—coding your solution—should be more straightforward.

Why This Opening Strategy Works

• Avoids Misunderstandings: Early clarification prevents wasted time on incorrect solutions.

• Builds Confidence: A structured plan reduces anxiety and boosts confidence.

• Brings Closer to The Solution: Focus on understanding and examples gets you to the solution faster.

• First Impressions Matter: Demonstrating a methodical approach impresses interviewers.

• Highlights Communication Skills: Engaging with the interviewer shows collaboration and problem-solving abilities.

Approaching your coding interviews with a well-defined opening strategy can significantly enhance your performance. By dedicating the first 15 minutes to understanding the problem thoroughly and outlining an optimal approach, you set yourself up for success in the rest of the interview.

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

In this issue, we’ll break down the essentials of priority queues and heaps, explore common problem patterns, and provide a step-by-step approach to help you tackle any heap-related problem.

Priority Queues vs Heaps

Let’s first clarify the difference between Priority Queues and Heaps.

tldr: Priority Queue is an idea of a data structure and Heaps are a concrete data structure that is the most common implementation of a Priority Queue.

What Is a Priority Queue?

A priority queue is an abstract data type similar to a regular queue or stack, but with an additional feature: each element has a "priority" associated with it. In a priority queue, elements are served based on their priority, not just their insertion order.

What Is a Heap?

A heap is a specialized tree-based data structure that satisfies the heap property:

• Max-Heap: In a max-heap, for any given node C, the value of C is less than or equal to the value of its parent P. The highest value is at the root.

• Min-Heap: In a min-heap, the value of C is greater than or equal to the value of its parent P. The lowest value is at the root.

Heaps are commonly used to implement priority queues because they allow for efficient retrieval and modification of the highest or lowest priority element. In practice, the two terms are often used interchangeably, but not by you - because now you know the difference.

When to Use Heaps: The Key Indicator

One of the biggest giveaways that heaps are appropriate is when the problem involves dynamic or streaming data. Heaps allow you to process incoming data as it arrives and provide the ability to query for the maximum or minimum value at any time. When the data is static, it is often sufficient to use a sorting algorithm. However, for dynamic datasets where elements are continually added or removed, heaps offer efficient O(log n) insertion and deletion operations, making them ideal for maintaining order in real-time.

Subscribe now

Common Problem Patterns Involving Heaps

1. Kth Largest/Smallest Element

Scenario: If the problem asks for the Kth largest or smallest element in a collection, heaps are ideal since they allow efficient insertion and extraction of the minimum or maximum element.

Example: "Find the Kth largest number in a stream."

Approach:

• Dynamic Data: Since the data may be continuously updated, a heap allows you to maintain the K largest elements efficiently.

• Implementation: Use a min-heap of size k to keep track of the top k largest elements in real-time.

LeetCode Example: 703. Kth Largest Element in a Stream

2. Merging or Sorting Multiple Lists

Scenario: Problems that require merging multiple sorted lists or arrays can often be optimized using a heap. This allows you to keep track of the smallest (or largest) element from each list and merge efficiently.

Example: "Merge k sorted linked lists into one sorted list."

Approach:

• Dynamic Selection: A heap helps you dynamically select the next smallest element among the heads of the lists.

• Implementation: Use a min-heap to store the current smallest element from each list.

LeetCode Example: 23. Merge k Sorted Lists

3. Frequent Elements

Scenario: If you're asked to find the top K most frequent elements or similar problems involving frequency and ranking, heaps can be used to efficiently maintain the top K elements as you process the data.

Example: "Find the top K most frequent words in a list of words."

Approach:

• Dynamic Counting: While the data may be static, heaps allow for efficient retrieval of the top frequencies without sorting the entire frequency map.

• Implementation: Use a min-heap of size k to keep track of the top K elements based on frequency.

LeetCode Example: 692. Top K Frequent Words

4. Dynamic Minimum/Maximum

Scenario: Any problem where you need to repeatedly access the minimum or maximum element in a dynamic dataset (inserting and removing elements) is a strong indicator for using a heap.

Example: "Design a data structure that supports inserting numbers and retrieving the maximum number at any time."

Approach:

• Dynamic Data: As elements are added or removed, the heap maintains the ordering.

• Implementation: Use a max-heap to maintain the maximum element.

LeetCode Example: 716. Max Stack

5. Scheduling or Task Execution

Scenario: If the problem involves scheduling tasks based on priorities or deadlines, a priority queue can help efficiently pick the next task to execute based on priority.

Example: "Given tasks with deadlines and durations, find the optimal schedule to maximize completed tasks."

Approach:

• Dynamic Selection: Tasks may be added or priorities may change; a heap allows for efficient retrieval of the highest priority task.

• Implementation: Use a heap to select the next task based on priority criteria (e.g., earliest deadline).

LeetCode Example: 621. Task Scheduler

6. Sliding Window Problems

Scenario: Problems where you need to track the maximum or minimum value in a sliding window (e.g., "find the maximum in each sliding window of size K") often benefit from heaps to efficiently maintain the range's top elements.

Example: "Find the maximum number in each sliding window of size K in an array."

Approach:

• Dynamic Window: As the window slides, elements enter and exit the window dynamically.

• Implementation: Use a max-heap to keep track of the maximum element in the current window, taking care to discard elements that are no longer in the window.

LeetCode Example: 239. Sliding Window Maximum

7. Shortest Path or Minimum Spanning Tree

Scenario: Graph-related problems like Dijkstra’s algorithm (for shortest paths) or Prim’s algorithm (for minimum spanning trees) make heavy use of priority queues to efficiently find the next node with the smallest cost.

Example: "Find the shortest path from a source node to all other nodes in a weighted graph."

Approach:

• Dynamic Edge Weights: The priority queue (min-heap) allows for efficient selection of the next node with the smallest tentative distance.

• Implementation: Use a min-heap to store nodes with their current shortest distance estimates.

LeetCode Example: 743. Network Delay Time

8. Order Statistics

Scenario: When the problem requires maintaining some sort of running order statistic, such as finding the median in a dynamic stream of numbers.

Example: "Design a data structure that supports adding numbers and finding the median."

Approach:

• Dynamic Median: As new numbers come in, the median can change.

• Implementation: Use two heaps—a max-heap for the lower half and a min-heap for the upper half—to maintain balance and efficiently compute the median.

LeetCode Example: 295. Find Median from Data Stream

Step-by-Step Approach to Solving Heap Problems

Step 1: Understand the Problem Thoroughly

1. Read Carefully: Ensure you understand what the problem is asking.

2. Identify Clues: Look for scenarios involving dynamic or streaming data, need for frequent access to min/max elements, or maintaining top K elements.

Step 2: Determine If a Heap Is Appropriate

1. Dynamic Data: If the data is dynamic (elements are added or removed over time), a heap is likely appropriate.

2. Real-Time Queries: If you need to query for the max or min at any time during data updates, consider using a heap.

3. Static Data: If the data is static and all you need is to find min/max or sort once, a sorting algorithm may suffice.

Step 3: Choose the Right Type of Heap

1. Min-Heap vs. Max-Heap:

   • Min-Heap: Access the smallest element.

   • Max-Heap: Access the largest element.

2. Combination:

   • Some problems require both (e.g., maintaining medians).

Step 4: Decide on the Programming Language and Libraries

• Python: Use the heapq module (min-heap). For max-heap, invert the values.

• Java: Use PriorityQueue class. For max-heap, provide a custom comparator.

• C++: Use priority_queue from STL. Default is max-heap.

• Ruby: Unfortunately heaps are not available in the standard Ruby libraries. Some platforms like Leetcode have the algorithms gem readily available but there is no guarantee that it will be available for you during your interview. I personally would make an assumption that there is some MaxHeap/MinHeap data structure available and then will implement it myself at the end if time permits.

Step 5: Implement the Solution

1. Initialize the Heap: Build the heap with initial elements if any.

2. Perform Heap Operations:

   • Insertion: Add elements as they come.

   • Deletion: Remove elements based on problem logic.

   • Peek: Access the top element without removing it.

Tips and Tricks

1. Dynamic vs. Static Data

Dynamic Data: When dealing with data that changes over time (insertions, deletions), heaps provide efficient O(log n) operations for maintaining order.

Static Data: If the dataset doesn't change, sorting algorithms (O(n log n)) may be more straightforward and sometimes more efficient for one-time processing.

2. Be Mindful of Element Indices

In problems like sliding window maximum, store indices along with values to know when to discard elements that are no longer within the window.

3. Simulating Max-Heap in Min-Heap Languages

In languages like Python, which only provide a min-heap, invert the values to simulate a max-heap.

heapq.heappush(max_heap, -num)

4. Combine Heaps with Other Data Structures

Sometimes, heaps alone may not suffice. Combining them with hash maps, deques, or other data structures can solve more complex problems.

5. Practice Standard Problems

Familiarize yourself with classic heap problems to recognize patterns quickly.

Summing Up

Mastering priority queues and heaps equips you with a powerful tool to efficiently solve a variety of problems that involve ordering, scheduling, and dynamically tracking extrema in datasets. These types of problems are quite frequent in coding interviews at top tech companies. Make sure to practice the problems referenced above as well as other problems tagged as “Heap”.

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

The Search for the Missing Piece

Over the past 20 years, I've been deeply involved in algorithmic coding challenges. Two decades ago, I started participating in competitive programming competitions, and in recent years, I've been mentoring people to improve their coding interview skills. Throughout this journey, I've used all kinds of resources to learn and teach algorithmic problem-solving.

While there are great problem archives like Leetcode or Codeforces, and excellent textbooks like Introduction to Algorithms (CLRS), I've found that there's no single unified resource that teaches the art of solving coding challenges in a holistic way. I wanted a resource that provides just enough theory and lots of relevant exercises, tailored to the needs of both coding interviews and competitive programming. With this book, I hope to bridge that gap.

Subscribe now

The Series

The book I'm working on, currently code-named Initiation, is actually the first in a series of eight books. The series is designed to take someone who has never encountered a coding challenge (but can code) all the way to being FAANG interview-ready.

Initiation is targeted at beginners and will cover fundamental topics such as nested loops, array indexing, hash tables, and time and space complexities—all within the context of coding challenges.

Here are a few features of the book that I'm particularly excited about:

• A Quest-Like Storyline: Set in the fictional School of Faangshui, you'll learn as an apprentice under Master Hashi, the legendary Grandmaster of Faangshui.

• Gradual Difficulty Build-Up: The topics and exercises are structured to progressively increase in difficulty, helping you build your skills step by step.

• Interactive Learning: The book provides just enough theory, accompanied by inline exercises that reinforce the concepts.

• Integrated Coding Platform: A built-in code editor and online judge offer immediate feedback on your code submissions.

• AI-Powered Feedback: Receive personalized feedback from Master Hashi himself, powered by AI, to help you improve your solutions.

The goal of the series is to make learning algorithmic problem-solving fun and interactive.

The Work Ahead

My original plan was to have an alpha version ready by the end of this month. I'm not sure if I'll make it in time, but here's what I've accomplished so far:

• Platform Development: I have a basic version of the platform ready, complete with a built-in online judge and AI-powered feedback from Master Hashi.

• Content Creation: I'm making steady progress on the content. So far, I have many pieces of text that need to be organized and connected.

• Balancing Story and Teaching: I haven't yet figured out how to balance the storyline with the instructional material. My hope is to test this with alpha readers and adjust based on their feedback.

• Attention to Detail: The more I work on the project, the more details I realize need to be addressed. It's a challenging but rewarding process.

Looking for Alpha Readers

There will be rough edges to smooth out and bugs to fix, and that's where you come in. If you're interested in being among the first to read the book and test the platform, please let me know by filling out this form. Your feedback will be invaluable, and I would greatly appreciate your help!

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

When I was kid, I dreaded encountering a dynamic programming problem in coding competitions. While I knew the theory and could solve classic problems, I often couldn't apply my knowledge to new DP problems where the solution wasn't immediately obvious.

But what confused me even more than the topic itself was the name dynamic programming. In what sense is it "dynamic"? Why "programming"? Aren't we always programming when we code? In a field where precise naming is important, this term feels generic and doesn't offer clues about the concept.

It turns out, that was intentional.

Subscribe now

The Origin Story

Richard Bellman, the mathematician who developed dynamic programming in the 1950s, shared an interesting anecdote in his autobiography "Eye of the Hurricane". At the time, Bellman was working at RAND Corporation, and the word "research" was frowned upon by the secretary of defense, who controlled the funding. Mathematical research, in particular, was under scrutiny.

To secure funding without attracting negative attention, Bellman chose the term "dynamic programming" to describe his work. The word "dynamic" implied action and progress, while "programming" was associated with planning and decision-making, not necessarily coding as we think of it today. The term was deliberately vague and non-threatening to the bureaucrats who might cut his budget.

Thanks to his ingenuity, Bellman was able to continue his research, leading to the development of dynamic programming and the Bellman equation. While the name doesn't make the concept any clearer, it served its purpose at the time—a small price to pay for such a valuable contribution to mathematics and computer science.

Embracing Dynamic Programming Today

Even though I haven't encountered a dynamic programming problem in a real-world project or interview yet, I still find the topic fascinating. I keep my DP problem-solving skills sharp and have largely overcome my earlier apprehension.

In a world as dynamic as ours, it's hard to predict when you'll need to "dynamically program" your way out of a problem. Understanding the history behind the term adds a layer of appreciation for the technique and reminds us that sometimes, names have stories that reflect the challenges of their time.

Stay curious and happy coding!

Nurbo

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

The answer to this question is simple: use the language you are most familiar with. Do not blindly default to Python unless that's the language you use most often.

Here's Why

During a coding interview, you want to impress your interviewers—not just by solving the problem, but also by demonstrating proficiency and fluency in the language you choose. Your choice reflects your technical abilities and your approach to work. In fact, many companies include "coding fluency" as one of the assessment criteria during interviews.

Using a language you're deeply familiar with allows you to:

• Write code more efficiently: You can focus on solving the problem rather than wrestling with syntax.

• Demonstrate best practices: Show your understanding of the language's idioms and nuances.

• Handle edge cases confidently: You're less likely to be tripped up by unfamiliar behavior or gotchas.

When to Use Python

There are only a few reasons to use Python during your interviews:

• It's the language you use at work: If Python is your primary language professionally, by all means, use it.

• You don't have a clear go-to language: If you're in college or have just graduated and haven't specialized in a particular language, Python is a good choice due to its readability and ease of use.

• Your only other language is Assembly.

Personal Experience

The last time I changed jobs and interviewed with several companies, I used Java, and it was perfectly fine. At the time, I worked at Amazon and wrote most of my code in Java, so it made sense to use it during interviews.

If I were to interview today, I would use Ruby, because that's the language I used daily at my last job at Chime and also for my side projects.

Could I write the code in Python? Probably, yes. But I don't know all the intricacies of Python to fully showcase my coding skills. Even though I'm familiar with Python's idioms, there could be a problem where I might need parts of Python that I haven't used as much.

In fact, during one of my interviews in my last job-hunting cycle, I needed advanced object-oriented programming (OOP) skills as well as data structures and algorithms (DSA) knowledge to fully solve the given problem. Had I used anything other than Java at the time, I might have failed that interview.

Why Do I Use Python in My Newsletter?

You may have noticed that much of my content includes examples in Python and often references Python's implementation of different functions and data structures. The reason is simple:

• Python is a common default: Many people choose Python when preparing for coding interviews due to its simplicity and readability.

• Widespread familiarity: Even if readers prefer a different language, they're often familiar with Python syntax, making the examples accessible.

• Focus on concepts: Using a universally understood language helps convey ideas without getting bogged down in language-specific details.

Bottom Line: Use the programming language you are most comfortable with during your interviews. It allows you to demonstrate your true potential and makes the problem-solving process smoother. While Python is a fantastic language, it's not the automatic choice for everyone—and that's perfectly okay.

I'm Accepting New Mentees!

Are you looking for a mentor to guide you and keep you accountable on your tech interview preparation journey? I'm here to help.

I'm opening up a few spots for motivated individuals who would benefit from weekly one-on-one mentorship sessions. Together, we'll:

• Develop a personalized study plan

• Master problem-solving techniques

• Build confidence for your interviews

Ready to take your preparation to the next level? Book a free introductory session with me here.

Stay curious and happy coding!

Nurbo

Keys Must Be Immutable and Hashable

In Python, dictionary keys must be immutable and hashable. A hashable object has a hash value that doesn't change during its lifetime and can be compared to other objects. This ensures the key's hash value remains constant, allowing efficient data retrieval.

Common Immutable and Hashable Types:

Integers (int):

my_dict = {1: "one", 2: "two"}

Strings (str):

my_dict = {"name": "Alice", "age": 30}

Tuples (with immutable elements):

my_dict = {(1, 2): "coordinates"}

Frozen Sets (frozenset):

my_dict = {frozenset({1, 2, 3}): "a frozenset"}

User-Defined Classes (with proper __hash__() and __eq__() methods):

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __hash__(self):
        return hash((self.x, self.y))

    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)

my_dict = {Point(1, 2): "A point"}

Mutable Types Cannot Be Dictionary Keys

Mutable objects are unhashable because their content can change, altering their hash value and compromising the dictionary's integrity.

Common Mutable and Unhashable Types:

Lists (list):

my_list = [1, 2, 3]
my_dict = {my_list: "list"} # Raises TypeError

Dictionaries (dict):

my_inner_dict = {"a": 1}
my_dict = {my_inner_dict: "dict"} # Raises TypeError

Sets (set):

my_set = {1, 2, 3}
my_dict = {my_set: "set"} # Raises TypeError

Understanding The Reason

Consistency Is Crucial

When you insert a key-value pair, Python computes the hash of the key to determine where to store the value. If the key's content changes after insertion, its hash value changes, and Python can't locate the key in the dictionary anymore.

Immutability Ensures Reliability

Immutability guarantees that the key remains the same throughout its lifetime, which is essential for maintaining data integrity and efficient retrieval.

Practical Tips for Coding Problems

• Use Immutable Types as Keys

  For composite keys, use tuples:

coordinates = (x, y)
my_dict[coordinates] = "value"

• Convert Mutable Objects to Immutable Equivalents

  Convert lists to tuples:

my_list = [1, 2, 3]
my_dict[tuple(my_list)] = "value"

• Ensure Custom Objects Are Hashable

  Implement __hash__() and __eq__() methods in your classes.

No Need to Memorize Specific Types

Focus on the principle:
If an object is immutable and hashable, it can be a dictionary key.

You can test if an object is hashable using the hash() function:

print(hash(42))          # Works
print(hash("hello"))     # Works
print(hash((1, 2, 3)))   # Works
print(hash([1, 2, 3]))   # Raises TypeError: unhashable type: 'list'

Conclusion

Understanding that dictionary keys must be immutable and hashable allows you to determine whether an object can serve as a key. This knowledge is essential when solving coding problems involving dictionaries or sets.

Stay curious and happy coding!
Nurbo

Need Help with Coding Interviews?

If you need one-on-one help with your tech interview preparation (coding, system design or behavioral) I can probably help you. Book a free introductory session with me here: https://link.faangshui.com/book.

Below I have gathered the top mistakes non-Pythonist candidates make when writing code during interviews, along with how to improve them.

1. Inefficient Looping Over Indices Instead of Elements

How People Write It:

nums = [1, 2, 3, 4, 5]
for i in range(len(nums)):
    print(nums[i])

How It Can Be Better Written:

nums = [1, 2, 3, 4, 5]
for num in nums:
    print(num)

Explanation:

• Issue: Using range(len(nums)) to iterate over list indices is unnecessary and less readable.

• Improvement: Directly iterate over the elements using for num in nums, which is more Pythonic and efficient.

2. Manually Managing Loop Indices When Enumerate Exists

How People Write It:

words = ["apple", "banana", "cherry"]
index = 0
for word in words:
    print(f"{index}: {word}")
    index += 1

How It Can Be Better Written:

words = ["apple", "banana", "cherry"]
for index, word in enumerate(words):
    print(f"{index}: {word}")

Explanation:

• Issue: Manually incrementing an index variable is error-prone and verbose.

• Improvement: Use enumerate() to get both the index and the element in each iteration.

3. Using Traditional Swapping Instead of Tuple Unpacking

How People Write It:

temp = a
a = b
b = temp

How It Can Be Better Written:

a, b = b, a

Explanation:

• Issue: The traditional method requires an extra variable and more lines of code.

• Improvement: Python's tuple unpacking allows swapping variables in a single, clear statement.

4. Not Utilizing defaultdict for Counting

How People Write It:

counts = {}
for item in items:
    if item in counts:
        counts[item] += 1
    else:
        counts[item] = 1

How It Can Be Better Written:

from collections import defaultdict
counts = defaultdict(int)
for item in items:
    counts[item] += 1

Explanation:

• Issue: Manually checking for key existence leads to verbose code.

• Improvement: Use defaultdict(int) to automatically initialize counts to zero.

5. Not Utilizing Counter from collections for Counting Elements

How People Write It:

def is_anagram(s, t):
    if len(s) != len(t):
        return False
    count_s = {}
    count_t = {}
    for c in s:
        count_s[c] = count_s.get(c, 0) + 1
    for c in t:
        count_t[c] = count_t.get(c, 0) + 1
    return count_s == count_t

How It Can Be Better Written:

from collections import Counter
def is_anagram(s, t):
    return Counter(s) == Counter(t)

Explanation:

• Issue: Manually counting elements is verbose and error-prone.

• Improvement: Use Counter to efficiently count elements and compare.

6. Not Using List Comprehensions for Simple Transformations

How People Write It:

squares = []
for num in nums:
    squares.append(num * num)

How It Can Be Better Written:

squares = [num * num for num in nums]

Explanation:

• Issue: Using loops for simple list transformations is less concise.

• Improvement: List comprehensions provide a readable and efficient way to create lists.

7. Not Using zip to Iterate Over Multiple Sequences

How People Write It:

for i in range(len(list1)):
    print(list1[i], list2[i])

How It Can Be Better Written:

for item1, item2 in zip(list1, list2):
    print(item1, item2)

Explanation:

• Issue: Using indices to access elements from multiple lists is less readable.

• Improvement: Use zip() to iterate over multiple sequences in parallel.

8. Not Using any() or all() for Checking Conditions

How People Write It:

def has_positive(nums):
    for num in nums:
        if num > 0:
            return True
    return False

How It Can Be Better Written:

def has_positive(nums):
    return any(num > 0 for num in nums)

Explanation:

• Issue: Writing loops for simple condition checks adds unnecessary code.

• Improvement: Use any() to check if any element meets a condition.

9. Re-Implementing sum(), max(), or min() Instead of Using Built-in Functions

How People Write It:

def find_sum(nums):
    total = 0
    for num in nums:
        total += num
    return total

How It Can Be Better Written:

def find_sum(nums):
    return sum(nums)

Explanation:

• Issue: Manually calculating sums or finding maximum/minimum values is unnecessary.

• Improvement: Use built-in functions like sum(), max(), and min() for clarity and efficiency.

10. Not Using set Operations for Common Set Logic (Intersection, Union, Difference)

How People Write It:

def common_elements(list1, list2):
    result = []
    for item in list1:
        if item in list2:
            result.append(item)
    return result

How It Can Be Better Written:

def common_elements(list1, list2):
    return list(set(list1) & set(list2))

Explanation:

• Issue: Manually checking for common elements is less efficient.

• Improvement: Use set operations like intersection (&), union (|), and difference (-) for cleaner and faster code.

11. Not Using Dictionary's get() Method with Default Values

How People Write It:

if key in my_dict:
    value = my_dict[key]
else:
    value = default_value

How It Can Be Better Written:

value = my_dict.get(key, default_value)

Explanation:

• Issue: Manually checking for key existence adds extra code.

• Improvement: Use dict.get() to simplify dictionary lookups with default values.

12. Not Using Slicing for Reversing Strings or Lists

How People Write It:

def reverse_string(s):
    reversed_s = ''
    for char in s:
        reversed_s = char + reversed_s
    return reversed_s

How It Can Be Better Written:

def reverse_string(s):
    return s[::-1]

Explanation:

• Issue: Building a new string character by character is inefficient.

• Improvement: Use slicing with [::-1] to reverse strings or lists efficiently.

Final Thoughts

Embracing Pythonic idioms not only makes your code more elegant but also demonstrates a deeper understanding of the language during interviews. Here's how to incorporate these practices:

• Practice writing code: Solve problems using Python to internalize these idioms.

• Review standard library: Explore modules like collections, itertools, and built-in functions.

• Read others' code: Look at well-written Python code to see these idioms in action.

Stay curious and happy coding!

Nurbo

Need Help with Coding Interviews?

If you need one-on-one help with your tech interview preparation (coding, system design or behavioral) I can probably help you. Book a free introductory session with me here: https://link.faangshui.com/book.

Over the past two months, I've reviewed hundreds of résumés from software engineers. Ninety percent of the folks who sent me their résumés already had great ones and didn't need to change a single character. Yet, ninety-nine percent of them were convinced that the reason they weren't being invited to interviews was because of their résumé.

What Résumés Are Really For

Your résumé serves two primary roles in your job application:

1. Initial Screening by Recruiters

   Recruiters scan your résumé to see if your qualifications match the required criteria of the position. They then forward a select few résumés to the hiring manager for approval to start the interview process.

2. Verification by Hiring Managers

   The hiring manager looks at your résumé to verify that you have the necessary experience and skills for the position they are hiring for.

There are other, less critical roles your résumé plays later in the process:

• Interview Preparation

  Some interviewers might glance at your résumé before the interview. Personally, I never looked at them to limit my bias toward the interviewee.

• Background Checks

  If you receive an offer, your résumé might be used during the background check process.

And that's essentially all your résumé is needed for.

Why Your Résumé Isn't the Problem

The current bottleneck—the single point of failure, if you will—is Step 1: Recruiters looking at your résumé. Because there are so many applicants right now, recruiters often don't review all applications thoroughly. They just need to find a few suitable candidates. Moreover, they usually prioritize:

• Referrals: Candidates recommended by current employees.

• Existing Applicant Database: Candidates who have applied for similar positions in the past.

Only after exhausting these pools might they look at new applications—if at all. That's where the problem lies, and that's why you're not being invited for interviews.

How to Solve the Issue

You can't change the market conditions.

But you can improve your own chances.

The tech job market is tough at the moment, so while you can't fix that, you can focus on strategies to get your résumé in front of recruiters.

So How Do You Do It?

1. Leverage Referrals

   Referrals, referrals, referrals. There's no guarantee, but they significantly increase your chances. Reach out to your network and see if someone can refer you.

2. Connect with Hiring Managers

   Even better is being referred by the hiring manager or a member of the team. This is where networking matters. Talk to people in the industry.

3. Be Early and Consistent

   Apply as soon as a job is posted and be consistent with your applications. It's a numbers game, and eventually, you'll hit the pool of candidates selected for interviews.

4. Increase Your Visibility

   • Write a Blog: Share your knowledge and insights.

   • Showcase Your Work: Contribute to open-source projects or build a portfolio.

   • Engage on Professional Platforms: Be active on LinkedIn and industry forums.

   Doing interesting stuff puts you on the radar of people who hire. This is a long-term strategy, but it's the only one entirely within your control.

How Else to Improve the Odds

• Optimize (Don't Overhaul) Your Résumé

  Make sure your résumé is decent: highlight the important stuff, keep it concise, and proofread it. No need to micro-optimize every detail.

• Tailor Your Résumé to Each Job

  Match your résumé to the job description. If they're hiring an AI/ML engineer, make your relevant work stand out. Applying for a backend position? Emphasize your backend experience. Adjusting your résumé for each application helps recruiters see the keywords and add you to their shortlist.

• Be Prepared

  When you get that interview invite—don't blow it. Prepare thoroughly and showcase your best self.

That's all, folks. Don't blame the résumé!

Stay curious and happy coding!

Nurbo

Psst… If you need one-on-one help with your tech interview preparation (coding, system design or behavioral) I can probably help you. Book a free session with me here: https://link.faangshui.com/book.

The short answer: I wanted to take a break to figure out what to do next while reconnecting with my extended family back in my home country.

You can stop reading right there—unless you want to know the longer answer.

The Longer Answer

Embracing a Sabbatical

Fifteen years ago (15 years! 🤯), I watched a TED talk by Stefan Sagmeister called "The Power of Time Off." That's when I heard the word sabbatical for the first time. Since then, I've always thought about how cool it would be to take one.

The basic idea of a sabbatical is to take a year off every few (usually seven) years to rest, recover, and get inspired. This is somewhat common in academia, but folks in other industries practice this as well.

Taking a sabbatical requires preparation, especially on the financial side. It eats into savings and is costly in terms of lost financial opportunities like career progression and compounding. Personally, I enjoy working, so I'm okay with retiring a bit later in life. So why not spend more time with family, work on fun stuff, and travel a bit while I'm still young and my kids are little?

The Entrepreneurial Twist

But here's the catch: I'm not taking the time completely off.

When I thought about what I'd do during my sabbatical, it wasn't hobbies that came to mind but a list of ideas I've been collecting for years. Most of these ideas have the potential to generate income. It's not something I specifically strive for, but creating products and businesses genuinely interests me.

I started and shut down a couple of startups many years ago, and despite the failures, that's when I had the most fun. I'd love to try starting something new again without the pressure of making it financially profitable. That's why I call this year my entrepreneurial sabbatical.

Reconnecting on the Personal Side

I've been living in Canada for a few years now and have become a Canadian citizen. We've been fortunate to have the chance and financial means to travel to see our parents or have them visit us every year. However, every time we met, it never felt like we had enough time together. It was also hard to visit all of our extended family whenever we went home.

It felt like the right time to reconnect with our immediate and extended families. Our kids are growing up quickly, and we wanted to ensure they have a deeper connection with their grandparents, cousins, uncles, aunts, and everyone else. That's why my wife and I decided to base ourselves in our home country during this sabbatical. The lower cost of living is an added bonus.

How It's Going So Far

My sabbatical started as we were finishing our trip to Europe, which we enjoyed immensely. After that, the last two months have been busy with non-work stuff:

• Immigration Process: We had to give up our previous citizenships when we became Canadians, so we went through the immigration process again. It's strange to be an immigrant in your home country.

• Family Visits: We've visited our families in two cities and attended several family events.

• Settling In: We've been busy looking for an apartment and a daycare for our kids.

On the Work Front

• This Newsletter: The first thing I started is this newsletter, which has been a fulfilling way to share my journey and insights.

• Writing a Book: I'm working on a book about solving algorithmic (aka Leetcode) challenges, something I've been thinking about for a few years. I plan to have the beta version ready by the end of the month. Stay tuned if you want to be one of the first readers/testers!

• Mentoring: I've taken on a few mentees whom I'm helping prepare for their interviews on a one-on-one basis. I have room for a few more. Working closely with people is something I've enjoyed throughout my career, and I intend to continue doing it even after my sabbatical is over.

What's Next

Aside from releasing my book, I'm looking forward to:

• Attending Weddings: Two of my high school buddies are getting married (not to each other) in the next two months. I wouldn't have been able to attend their weddings if I weren't on sabbatical.

• Travel Plans: I'm planning a trip to Southeast Asia in the winter and a trip to South Korea in the spring.

• Embracing the Unknown: Beyond that, I don't really know what I'll be doing next. And that's the beauty of this sabbatical.

Stay curious and happy coding,

Nurbo

They perform insertion, deletion, and lookup operations in just constant average time—O(1) time complexity.

Let’s dive into the mechanics of hash tables to uncover the secrets behind their speed.

At their core, hash tables (also known as hash maps or dictionaries) store key-value pairs. They provide a way to map keys to values for highly efficient data retrieval. The primary components of a hash table are:

• An array (or list): This serves as the underlying storage mechanism.

• A hash function: A function that takes a key and computes an index in the array where the corresponding value should be placed.

Achieving O(1) Time Complexity

1. Efficient Hash Functions

The hash function is pivotal in achieving constant-time operations. It transforms a key into an index in the array:

index = hash_function(key)

A good hash function has the following properties:

• Deterministic: The same key always yields the same index.

• Uniform Distribution: It distributes keys uniformly across the array to minimize collisions.

• Fast Computation: It computes the index quickly to maintain O(1) performance.

By directly computing the index, the hash function allows the hash table to jump to the exact location where the value should reside, eliminating the need for linear searches.

2. Collision Resolution

Despite a good hash function, different keys can sometimes produce the same index—a situation known as a collision. Efficient collision resolution strategies are essential for maintaining O(1) time complexity.

Collision Resolution Techniques

• Chaining (Separate Chaining):

  • Each array index points to a linked list (or another data structure) containing all key-value pairs that hash to that index.

  • Advantage: Simple to implement and handles a large number of collisions gracefully.

  • Average Case: O(1), assuming the linked lists remain short due to a good hash function and appropriate array size.

• Open Addressing (Probing):

  • When a collision occurs, the hash table probes for the next available slot according to a probing sequence (e.g., linear probing, quadratic probing).

  • Advantage: All data is stored within the array itself, which can improve cache performance.

  • Average Case: O(1), but performance can degrade if the table becomes too full.

3. Maintaining an Appropriate Load Factor

The load factor is the ratio of the number of stored elements to the size of the array. To maintain O(1) performance, the load factor should be kept below a certain threshold (commonly around 0.7 to 0.75).

• Rehashing: When the load factor exceeds the threshold, the hash table resizes (typically doubling in size) and rehashes all existing keys into the new array. This operation is costly (O(n)) but happens infrequently and is amortized over many operations.

Implementation in Python

Python's built-in dict type is a highly optimized hash table implementation. Let’s look at how Python achieves O(1) time complexity in its dictionaries considering the concepts discussed above.

Hash Function in Python

• Python uses the built-in hash() function to compute hash values for keys.

• For immutable built-in types like integers, strings, and tuples, Python provides optimized hash functions.

• Custom objects can define their own __hash__() method.

Example:

key = "example"
hash_value = hash(key)

• The hash_value is an integer that represents the hash of the key.

• The hash value is then used to compute the index in the underlying array, typically via modulo operation.

Collision Resolution in Python

Python uses Open Addressing with Perturbation Probing, a variant of Quadratic Probing.

Perturbation Probing

• When a collision occurs, Python calculates a new index using a perturbation value that changes with each probe.

• This approach reduces clustering and ensures that all slots are eventually probed.

Simplified Pseudocode:

index = hash(key) % array_size
perturb = hash(key)
while array[index] is not empty and array[index].key != key:
    index = (5 * index + 1 + perturb) % array_size
    perturb >>= 5

• Explanation:

  • index is the initial position calculated using the hash of the key.

  • If the slot at index is occupied by a different key, the perturbation probing sequence computes a new index.

  • The perturb variable alters the probing sequence to minimize clustering.

Load Factor and Resizing

• Python's dictionaries maintain a load factor of around 2/3.

• When the number of entries exceeds 2/3 of the array size, the dictionary resizes to a larger size (usually doubling).

• Resizing involves rehashing all existing keys into the new array.

Example:

# Python automatically handles resizing
my_dict = {}
for i in range(100000):
    my_dict[i] = i

• In this example, my_dict will resize multiple times as elements are added.

• The resizing ensures that the load factor remains optimal for performance.

Optimizations in Python's Dictionaries

• Entry Ordering: Since Python 3.6, dictionaries maintain insertion order.

• Sparse Arrays: The underlying array is kept sparse to reduce collisions.

• Compact Storage: Python uses a combined table to store entries efficiently, reducing memory overhead.

Why Hash Tables are Fast on Average

By combining a good hash function with efficient collision resolution and maintaining a proper load factor, hash tables ensure that:

• Insertions: Place the element directly at the computed index or resolve collisions quickly.

• Lookups: Access the element directly via its index, minimizing the number of comparisons.

• Deletions: Locate the element swiftly and remove it without extensive shifting of other elements.

These factors contribute to the constant average time complexity. While the worst-case time complexity can be O(n) (e.g., when all keys collide to the same index), a well-designed hash table makes such scenarios highly unlikely.

Conclusion

Hash tables achieve O(1) time complexity through the clever use of hash functions, efficient collision resolution techniques, and by maintaining an appropriate load factor. Python's implementation of dictionaries exemplifies these principles, providing a powerful and efficient tool for developers.

Key Takeaways:

• Hash Functions: Transform keys into array indices for direct access.

• Collision Handling: Essential for maintaining performance; Python uses open addressing with perturbation probing.

• Load Factor: Keeping it low ensures operations remain O(1) on average.

• Amortized Performance: Occasional expensive operations (like rehashing) are offset by many fast operations.

• Immutability: Use immutable types for keys to ensure consistent hashing.

Need Help with Coding Interviews?

Are you struggling with coding problems or feeling unprepared for your upcoming interviews? You're not alone, and I'm here to help.

With years of experience as a coding interview coach, I offer personalized one-on-one sessions to:

• Master problem-solving skills for coding and system design interviews

• Boost your confidence for the big day

• Develop effective strategies to level up your tech career

Ready to elevate your coding interview skills? Book a personalized 1:1 coaching session with me today!

Still have questions? Let's chat! You can book a free 30-minute consultation to discuss how I can help you achieve your goals.

Feel free to email me at nurbo.kusmagul@(google’s email service) or connect with me on LinkedIn.

Looking forward to helping you succeed!

Stay curious and happy coding!

Nurbo