Forem: Messaoud Wael

Master Coding Interviews : Part 3 ( Fast & Slow Pointers Pattern )

Messaoud Wael — Tue, 31 Mar 2026 11:57:59 +0000

In Part 1 we saw how a sliding window collapses a nested loop into a single pass over an array. In Part 2 we used two pointers moving toward each other — or side by side — to restructure and search sorted arrays in O(n) time and O(1) space.

Today's pattern shares that same O(1) space philosophy, but it lives in a different world: linked lists. Meet the Fast & Slow Pointers pattern — also known as Floyd's Cycle Detection Algorithm.

What is the Fast & Slow Pointers Pattern?

The concept comes from a simple real-world intuition: imagine two runners on a circular track. One runs twice as fast as the other. If the track loops back on itself, the fast runner will eventually lap the slower one — they are guaranteed to meet. If the track is a straight line with a finish line, the fast runner simply gets there first and stops.

We apply exactly this logic to linked lists:

The slow pointer advances one node at a time
The fast pointer advances two nodes at a time
If the list has a cycle, they will eventually collide inside it
If the list has no cycle, the fast pointer hits the end (null) and we stop

This pattern is remarkably versatile: it detects cycles, finds the middle of a list, and even identifies the entry point of a cycle — all without any extra data structures.

Problem 1 — Linked List Cycle

Given the head of a singly linked list, determine if the linked list has a cycle in it or not. Return True if there is a cycle, False otherwise.

Example:

Input: head = [3, 2, 0, -4] where the tail connects back to the node at index 1
Output: True

The most natural solution that comes to mind is to keep track of every node we visit using a hash set. If we ever encounter a node we've seen before, we know there's a cycle.

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        visited = set()
        current = head

        while current:
            if current in visited:
                return True   # We've seen this node before — cycle detected
            visited.add(current)
            current = current.next

        return False  # Reached the end of the list — no cycle

This solution works correctly, but it comes with a cost we can't ignore:

Space complexity : O(n) : We store a reference to every visited node in the hash set — for a linked list with a million nodes, that's a million references sitting in memory.
In memory-constrained environments — embedded systems, low-resource servers, or simply very large linked lists — allocating that extra data structure is not always acceptable.
The problem itself hints at a better path: can you solve it using O(1) memory ?

Optimization through the Fast & Slow Pointers Pattern

Here's where Floyd's algorithm shines. We replace the hash set entirely with just two pointers — and get O(1) space as a result.

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        slow = head   # Tortoise: moves one step at a time
        fast = head   # Hare: moves two steps at a time

        while fast and fast.next:
            slow = slow.next          # Tortoise takes one step
            fast = fast.next.next     # Hare takes two steps

            # If the pointers meet, the hare has lapped the tortoise
            # — a cycle exists
            if slow == fast:
                return True

        # Fast pointer reached the end of the list — no cycle
        return False

Time complexity : O(n) — in the worst case, the fast pointer traverses the list once.

Space complexity : O(1) — two pointers, no auxiliary data structure.

Why does it work ? If a cycle exists, the fast pointer enters it and begins "lapping" the slow pointer. Each iteration, the gap between them shrinks by exactly one step. Since the gap is finite and decreases by one per iteration, they are mathematically guaranteed to meet. If there is no cycle, the fast pointer reaches null and the loop exits cleanly.

Problem 2 — Middle of the Linked List

Given the head of a singly linked list, return the middle node of the linked list. If there are two middle nodes, return the second middle node.

Example:

Input: head = [1, 2, 3, 4, 5]
Output: Node with value 3

The straightforward solution is to count all nodes in a first pass, then walk to the midpoint in a second pass.

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        length = 0
        current = head

        # First pass: count all nodes
        while current:
            length += 1
            current = current.next

        # Second pass: walk to the middle
        middle = length // 2
        current = head
        for _ in range(middle):
            current = current.next

        return current

This is perfectly correct, and it does run in O(n) time — but it makes two full passes over the list and requires you to know the total length before you can find the middle. Can we find the middle in a single pass, without knowing the length upfront ?

Optimization: Finding the Middle in One Pass

This is where the Fast & Slow Pointers pattern reveals a second superpower. Since the fast pointer moves at twice the speed of the slow pointer, by the time the fast pointer reaches the end of the list, the slow pointer will have traveled exactly half the distance — landing precisely at the middle.

class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow = head   # Will reach the middle when fast reaches the end
        fast = head   # Moves twice as fast as slow

        while fast and fast.next:
            slow = slow.next          # One step
            fast = fast.next.next     # Two steps

        # When fast is at the end, slow is at the middle
        return slow

Time complexity : O(n) — a single pass through the list.

Space complexity : O(1) — no extra memory allocated.

The two-pass approach and this one-pass approach share the same time complexity on paper, but the single-pass version is cleaner and more elegant — and it demonstrates a deep understanding of the pattern that interviewers notice.

When to use this pattern

When dealing with linked lists where you need to detect or reason about cycles
When you need to find the middle of a linked list in a single pass
When the problem asks for O(1) space on a linked list problem — this is almost always the signal
When the brute-force solution uses a hash set to track visited nodes — that extra space is almost always replaceable with fast & slow pointers
When the problem involves cyclic sequences, repeated states, or asks for the entry point of a cycle

What's next ? Practice

Head over to LeetCode and explore the linked list problem set. A few great next problems to challenge yourself with this pattern:

Linked List Cycle II (Medium) — can you find the exact node where the cycle begins ?
Happy Number (Easy) — fast & slow pointers applied to a numeric sequence, not a list
Reorder List (Medium) — combines middle-finding with a reversal

PS: Not every linked list problem requires this pattern, and Floyd's algorithm isn't the only way to detect a cycle. Keep building your instinct for when a pattern fits — that recognition is the real skill interviewers are testing.

See you in the next article for another coding pattern !

Master Coding Interviews : Part 2 ( Two Pointers Pattern )

Messaoud Wael — Mon, 30 Mar 2026 16:32:27 +0000

If you read Part 1 of this series, you already know how a single pattern can transform a slow, brute-force solution into an elegant, optimized one. Today we're going to do the same thing — but with a different tool in our belt: the Two Pointers pattern.

This one is everywhere in coding interviews. Once you recognize it, you'll start seeing it in problems you might have struggled with before.

What is the Two Pointers Pattern?

The idea is simple: instead of using one index to iterate through your data structure, you use two. These two pointers move through the array (or string) according to specific conditions, and together they help you find the answer without needing nested loops.

There are two main variants you'll encounter:

Opposite-direction pointers : One pointer starts at the beginning, the other at the end. They move toward each other until they meet.
Same-direction pointers (fast & slow) : Both pointers start at the same end, but move at different speeds or under different conditions.

Let's jump straight into a problem to see the first variant in action.

Problem 1 — Two Sum II: Input Array Is Sorted

Given a 1-indexed array of integers numbers that is already sorted in non-decreasing order, find two numbers such that they add up to a specific target number. Return the indices of the two numbers as an integer array [index1, index2] of length 2.

The brute-force approach is fairly intuitive: try every possible pair and check whether it adds up to the target.

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        for i in range(len(numbers)):
            for j in range(i + 1, len(numbers)):
                if numbers[i] + numbers[j] == target:
                    return [i + 1, j + 1]  # 1-indexed result
        return []

This works — but just like in Part 1, it hides a performance problem we can't ignore:

Time complexity : O(n²) : For an array of 30,000 elements, this is potentially 900 million comparisons.
Time Limit Exceeded : For large inputs on LeetCode, this solution will almost certainly hit the TLE wall.
In a real production context, a quadratic loop like this over large datasets is a performance bottleneck waiting to happen.

Optimization through the Two Pointers Pattern

Here's the key insight we're missing in the brute-force: the array is already sorted. That's a hint the problem is giving us for free, and the Two Pointers pattern is exactly how we take advantage of it.

We place one pointer at the very beginning of the array (left) and one at the very end (right). Then we look at their sum:

If the sum equals the target → we're done.
If the sum is too large → we need a smaller number, so we move right one step to the left.
If the sum is too small → we need a larger number, so we move left one step to the right.

Each iteration eliminates a candidate, and since both pointers are converging toward the center, we'll find the answer — or confirm it doesn't exist — in a single pass.

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        left = 0                    # Left pointer starts at the beginning
        right = len(numbers) - 1   # Right pointer starts at the end

        while left < right:
            current_sum = numbers[left] + numbers[right]

            if current_sum == target:
                # Found the pair — return 1-indexed positions
                return [left + 1, right + 1]

            elif current_sum > target:
                # Sum is too large: move right pointer inward to get a smaller value
                right -= 1

            else:
                # Sum is too small: move left pointer inward to get a larger value
                left += 1

        return []  # No solution found (problem guarantees one exists, but good practice)

This brings us down to O(n) time complexity and O(1) space complexity — a dramatic improvement over the brute-force approach, and it passes LeetCode with no issues.

Variant 2 — Same-Direction Pointers

The second variant doesn't converge from opposite ends. Instead, both pointers start from the same side and move in the same direction, but at different speeds or under different conditions. This is perfect for problems where you need to restructure an array in-place or detect a specific pattern as you scan forward.

Let's look at a classic example.

Problem 2 — Remove Duplicates from Sorted Array

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. Return the number of unique elements k.

The naïve instinct here might be to use a set to collect unique values and rebuild the array — but the problem explicitly requires an in-place solution using O(1) extra memory. A set would cost us O(n) space, which defeats the purpose.

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        seen = set()
        result = []

        for num in nums:
            if num not in seen:
                seen.add(num)
                result.append(num)

        # This doesn't satisfy the in-place constraint
        for i in range(len(result)):
            nums[i] = result[i]

        return len(result)

Beyond the space constraint violation, this approach creates auxiliary data structures we don't need. The Two Pointers pattern gives us a cleaner — and compliant — solution.

Optimization: Same-Direction Two Pointers

Here's the idea: we use a slow pointer to track the position where the next unique element should be written, and a fast pointer to scan ahead through the array looking for new unique values. Whenever fast finds a value different from what slow is pointing at, we advance slow and write that new value there.

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        # 'slow' marks the boundary of our unique-elements section
        slow = 0

        # 'fast' scans ahead to discover new unique elements
        for fast in range(1, len(nums)):

            # When fast finds a value different from slow's position,
            # a new unique element has been discovered
            if nums[fast] != nums[slow]:
                slow += 1                  # Expand the unique section
                nums[slow] = nums[fast]    # Write the new unique value in place

        # slow is now the index of the last unique element
        # so the count of unique elements is slow + 1
        return slow + 1

Time complexity : O(n) — fast does a single pass through the array.

Space complexity : O(1) — everything is done in-place, no extra data structures.

The elegance here is that the two pointers work as a team: fast does the exploration, slow does the writing. They never interfere with each other because slow can only be at or behind fast.

When to use this pattern

When dealing with sorted arrays or strings (a big hint for opposite-direction pointers)
When the problem asks you to find a pair (or triplet) of elements that satisfy a condition
When you need to restructure or deduplicate an array in-place with O(1) space
When the brute-force solution involves nested loops over the same linear data structure — that's almost always a signal that two pointers can collapse it to O(n)

What's next ? Practice

Head over to LeetCode and try the Two Pointers problem list — there are over 200 problems tagged with this pattern. Start with the easy ones to build your instinct, then move into medium difficulty.

A few good ones to try next:

Container With Most Water (Medium) — opposite-direction pointers
3Sum (Medium) — two pointers inside an outer loop
Linked List Cycle (Easy) — fast & slow pointers on a linked list

PS: As with the Sliding Window pattern, Two Pointers isn't always the only valid approach. It's a powerful tool when certain conditions are met — sorted data, in-place constraints, pair/subset problems — but always think about whether the pattern genuinely fits before reaching for it.

See you in the next article for another coding pattern !

Master Coding Interviews : Part 1 ( Sliding Window Pattern )

Messaoud Wael — Thu, 29 Jan 2026 20:34:00 +0000

If you’re having a coding interview, and that you are overwhelmed by the number of coding problems out there, you’re not alone. Especially when you are in a hurry, you want to grasp as much problem solving skills as possible, and this article ( and other parts coming up ) exist to help you with that.

When tackling a coding problem, there is generally a pattern of how to solve it; what I mean by pattern is the way you want to approach the problem efficiently ( in terms of space and time complexity ) based on the problem requirements.

Problem

Let’s look at a specific problem to showcase today’s pattern in practice.

The first simple solution that may come to mind is to compute the average of all possible sub-arrays and return the maximum value.

class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        max_avg = -1000

        for i in range(len(nums) - k + 1):
            current_sum = 0
            for j in range(i, i + k):
                current_sum += nums[j]
            max_avg = max(max_avg, current_sum / k)

        return max_avg

This solution works fine, however we may encounter some potential problems with it :

Time complexity : O(n*k) : So for example, If $n = 100,000$ and $k = 50,000$, this solution would perform roughly 5 billion operations
Time Limit Exceeded issue: For large inputs, and in specific environment settings, this solution may resolve in a time limit issue because the environment has a threshold of operations per second. For example, in LeetCode, for a large input it has raised the TLE error.

Outside online problem solving platforms, in a real-world solution, this may result in high CPU usage which may result in potential “hangs” for the users

Optimization through the Sliding Window Pattern

We could improve the solution using a sliding window pattern :

As the name suggests, we try to construct a window that grows and shrinks according to the requirements of the problem, and perform the main solution within that window. Let me showcase that:

class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        current_sum = 0
        left = 0 # Left boundary of the window
        avg = 0
        max_avg = -1000

        # The index used inside the loop represents the right boundary of the window
        # So window size is: right - left + 1
        for right in range(len(nums)): 
            diff = right - left + 1
            current_sum += nums[right]

            # If window's size attains the required length for the subset
            # we have to adjust its size by incremeting the left index 
            # after calculating the average value
            if diff == k:
                avg = current_sum / k
                max_avg = max(avg,max_avg)
                current_sum -= nums[left]
                left +=1

        return max_avg

This algorithm optimizes the previous solution with O(n) time complexity and the same O(1) space complexity.

When to use this pattern

When dealing with linear data structures ( lists, string,… )
The solution has to deal with finding some subset

What’s next ? Practice

You may use the LeetCode platform online and pick some sliding window problems from there to practice. You have a set of 161 questions !

PS: Some of these problems may be solved efficiently, not only by using this pattern. Keep in mind that a pattern exists to help you with one way of solving a problem when some requirements are gathered, but may not be the only approach we could use !

See you in the next article for another coding pattern !

Azure Fundamentals Series : NSG vs Firewall

Messaoud Wael — Thu, 22 Jan 2026 01:05:58 +0000

Azure Firewall and Network Security groups are two of the most common security components used in the Azure network infrastructure. Their main role is controlling the inbound and outbound traffic by filtering unwanted traffic, and that's where the confusion comes from. If they are so similar at first glance, how do they differ and when to use each one ?

Comparison

Below is a summarized comparison table between the main features of the 2 security services, followed by a deeper explanation for each comparison.

	Azure Firewall	Network Security Group
Security service to secure	VNet	a resource/subnet
Operates on OSI layer	3, 4 & 7	3 & 4
Uses	application, transport, network,NAT rules and threat intelligence	basic network and transport rules
Has intelligent threat mechanism built in	Blocks traffic from known malicious IPs automatically	Doesn't have a built-in intelligent-threat mechanism
Cost	Paid-service	Free ( Part of the Resource / Subnet cost )
Scaling	Supports auto-scaling	Does not scale; it is just a list of rules applied to a subnet/resource.

Application Scope

NSG works at the resource-level: It is directly attached to:

A subnet (filtering traffic for all resources in that subnet)
A network interface (NIC) of a Virtual Machine

Azure Firewall works at the network-level: It is deployed into a dedicated subnet within a VNet. You route traffic through it. This allows it to protect:

An entire VNet (by applying routes to its subnets)
Multiple VNets (via peering or Virtual WAN Hub)
Specific subnets within a VNet

💡 A small dive into how a Firewall works : We define an Azure Route Table in which we specify User-Defined-routes ( a destination IP address + next hop address which in our case , is going to be a private IP address representing the network location of our firewall ). We assign this table to each subnet, so we can ensure that all traffic coming to our destination is being redirected to the Firewall.

Layers they work on

( 2nd point of comparison, which will also include the 3rd and 4th ones, and you'll understand how they are bound together )

NSG operates as a stateless and isolated packet-filtering tool at the Network (Layer 3) and Transport (Layer 4) layers. It makes simple allow/deny decisions based on the fundamental information in packet headers.

It inspects 5 parameters :

Source IP Address (Layer 3)
Destination IP Address (Layer 3)
Protocol (e.g., TCP, UDP) (Layer 4)
Source Port (Layer 4)
Destination Port (Layer 4)

Key Limitation - Stateless: NSG does not understand if a packet is part of an existing, legitimate conversation. You must explicitly define rules for both the initial request (e.g., Port X → Port 80) and the traffic's return (Port 80 → Port X).

Azure Firewall is a stateful tool that inspects traffic at Network (L3), Transport (L4), and Application (L7) layers.

Layer 3 & 4 (Stateful Inspection): Like an NSG, it sees IPs, ports and the used protocol. However, it is stateful, in other words, it understands and tracks the state of network connections. A very simple example to understand this is, if a VM placed inside an internal subnet initiates an outbound connection to the internet, the firewall automatically allows the return traffic back to that VM without needing an explicit inbound rule. This simplifies management and increases security.

Layer 7 (Application Layer): Azure Firewall have some superpowers operating at this layer ! It is actually capable of inspecting the actual content of the traffic to make intelligent decisions.

FQDN Filtering: Can allow or deny traffic based on Fully Qualified Domain Names (e.g., *.windowsupdate.microsoft.com), not just IP addresses, which are dynamic and can change.
Application Rules: Can identify traffic based on the application protocol (e.g., WindowsUpdate, AzureKubernetesService).
Web Categories: Can filter outbound web traffic by categories (e.g., Social Media, Gambling).
Threat Intelligence: Can alert and deny traffic to/from known malicious IP addresses and domains.
Network Address Translation (NAT): It provides DNAT (Destination NAT) rules, which allow you to translate a public IP on the firewall to a private IP/port inside your VNet (e.g., exposing an internal SSH server securely).

Cost-comparison

NSG is a built-in networking resource in Azure with no additional charge, since it comes as a protection layer with the resource you're paying for ( e.g., Virtual Machine )

However, Azure Firewall is a platform-as-a-service (PaaS) offering with associated costs that scale with features and throughput. Cost differs between different existing tiers ( Basic, Standard and Premium )

Scaling

While NSG rules automatically apply to new resources within their assigned subnet or NIC, they are inherently static configurations. This can create operational challenges. For example, when scaling your infrastructure, like provisioning new VMs across multiple regions for a Black Friday event, each new environment or unique traffic pattern may require manual rule duplication or some reevaluation of IP ranges => separate manual management. NSG scales with your resources but does not dynamically adapt to your evolving security needs.

On the other hand, Azure Firewall addresses this through centralized policy management. A single firewall policy governs traffic for all resources, regardless of scale. When you provision new VMs or expand to new regions, the security rules automatically apply without duplication so enabling true scalability.

Furthermore, Azure Firewall is designed as a resilient service. It can be deployed across multiple Availability Zones, providing automatic failover and high availability (e.g., up to 99.99% SLA for Premium SKU deployments).

Quick Analogy

Think of Azure Virtual Network as a corporate campus. In this context, Azure Firewall is the main security gatehouse that all vehicles must pass through to enter or leave the campus grounds. NSGs are the individual door locks and/or department access cards that control movement within the buildings and offices once inside.