Chapter 3: Two Pointers & Sliding Window

Week 3

Master the two pointer technique for scanning sequences from both ends or in tandem, then learn sliding window patterns that maintain a moving subarray to solve range-based problems in linear time. These patterns eliminate nested loops and are among the most frequently tested in interviews.

Topics: 8
Demos: 5
Videos: 3
Min read: 34

Chapter Overview

Two pointers and sliding window are arguably the highest-value patterns in all of DSA interviewing. They transform problems that seem to require O(n^2) brute force into elegant O(n) solutions by maintaining state as pointers sweep through the data.

Two pointers come in two flavors. Same-direction pointers (often called "slow and fast") walk through the array together, with the fast pointer exploring ahead while the slow pointer marks a boundary. Opposite-direction pointers start at both ends and move inward, exploiting sorted order or symmetry to skip unnecessary comparisons.

Sliding window extends the two-pointer idea to subarrays and substrings. A fixed-size window slides across the array, updating its aggregate in O(1) per step. A variable-size window expands to include new elements and shrinks from the left when a constraint is violated, solving "longest/shortest subarray with property X" problems efficiently.

Finally, we cover two closely related techniques: prefix sums, which precompute cumulative totals so any range sum can be answered in O(1), and Floyd's cycle detection, which uses fast and slow pointers on linked structures to detect loops in O(1) space.

This chapter covers:

Same & opposite direction pointers: Core two-pointer strategies
Classic two-pointer problems: Remove duplicates, two sum sorted, valid palindrome
Fixed-size sliding window: Maximum sum subarray of size k
Variable-size sliding window: Longest and shortest windows with constraints
Prefix sums: O(1) range queries after O(n) preprocessing
Cycle detection: Floyd's tortoise and hare algorithm

Chapter Roadmap

Click any topic to jump in

Explainer videoInteractive demo

Two Pointers

Two indices walking an array together — the building block for in-place transforms, pair search, and sliding windows.

Same-Direction (Fast & Slow) PointersOpposite-Direction Pointers

Two flavours of two pointers

Same-direction pointers for in-place rewriting, opposite-direction for pair search.

In-Place Rewriting

Same-direction pointers (read/write) compact arrays in $O(n)$ time and $O(1)$ extra memory.

In-Place Deduplication with Two PointersAllow At Most K Duplicates

Two Sum / Three Sum

Opposite-direction pointers find target pairs on sorted arrays in linear time — the basis of $k$-sum reductions.

Two Sum with Opposite PointersThree Sum Reduction

From transforms to symmetric checks

Palindrome Checks

Opposite-direction pointers compare mirrored positions — extensions handle filtering and tolerated mismatches.

Basic Palindrome Check with Two PointersValid Palindrome with At Most One Removal

From single pointer to window

Sliding windows generalise two pointers to maintain state over a contiguous range.

Fixed Window

A window of exactly $k$ elements — amortised $O(1)$ per step using incremental updates.

Maximum Sum Subarray of Size KSliding Window with Auxiliary Data Structures

Variable Window

Expand-then-shrink windows — each index is visited at most twice, keeping the total $O(n)$.

Longest Window Pattern (Expand Until Invalid)Shortest Window Pattern (Shrink After Valid)

Range queries and cycle finding

Prefix sums answer range queries; tortoise & hare uses two pointers on linked structures.

Prefix Sums

Cumulative sums turn range-sum queries into two array reads — combine with hash maps for subarray-sum problems.

Building and Using Prefix SumsSubarray Sum Equals K with Prefix Sum + Hash Map

Floyd's Tortoise & Hare

Two pointers moving at different speeds detect cycles in $O(n)$ time and $O(1)$ space.

Tortoise and Hare AlgorithmFinding Duplicates with Floyd's Algorithm

Topics

8 topics in this chapter

Suppose you must check whether any two numbers in a list of 100,000 values add up to a target, or strip every zero out of an array without allocating a second one. The obvious approach compares every pair with nested loops, about five billion comparisons for 100,000 elements. That is far too slow, and most of those comparisons are wasted because their outcome was predictable from ones already made.

The previous chapter, Binary Search, showed how ordered data lets one comparison discard half of the candidates. Two pointers apply a similar idea to a linear sweep: two indices move through the data, and each comparison lets one of them advance past an element that can never matter again. Since each pointer moves at most n times, the total work is O(n).

This topic introduces the two basic layouts. Same-direction pointers, a fast reader and a slow writer, compact or partition an array in place. Opposite-direction pointers start at both ends and close in, using sorted order or symmetry to decide which end to move. Every later topic in this chapter builds on one of these two shapes.

Definition

The two-pointer technique scans a sequence with two indices whose positions encode an invariant. Same-direction pointers both move left to right, a fast read index ahead of a slow write index. Opposite-direction pointers start at the two ends and move inward. Because neither pointer ever moves backwards, the scan finishes in O(n) time with O(1) extra space.

In this topic

1Same-Direction (Fast & Slow) Pointers
2Opposite-Direction Pointers

1 of 2

Same-Direction (Fast & Slow) Pointers

In-place problems forbid a second array, yet you still need to separate the elements you keep from the ones you drop. Same-direction pointers do this with two indices that both start at 0. The fast index reads every element exactly once; the slow index marks where the next kept element should be written. The invariant is that nums[0..slow-1] holds exactly the kept elements, in their original order. When nums[fast] passes the test, write or swap it into position slow and increment slow; otherwise only fast advances. A common bug is incrementing slow unconditionally, which keeps everything. This one pattern powers removal, deduplication, and stable partitioning.

Mathematical Intuition

Two indices $i$ (fast, read) and $j$ (slow, write) both advance from $0$ . The invariant is that $a[0..j-1]$ already holds the finalised output. Because each pointer moves only forward and at most $n$ times, the total work is $\Theta(n)$ time and $O(1)$ extra space — strictly better than any solution that allocates a new array.

Example:

Given an array [0, 1, 0, 3, 12], move all zeros to the end while maintaining the relative order of non-zero elements. Do this in-place.

2 of 2

Opposite-Direction Pointers

One pointer starts at the beginning, the other at the end. They move toward each other based on a comparison or condition. This is ideal for sorted arrays (where the sum of endpoints guides which pointer to move), palindrome checking (comparing characters from both ends), and container problems (where width decreases as pointers converge). The loop runs while left < right, visiting each element at most once for O(n) time.

Mathematical Intuition

Two indices $l$ (from the left) and $r$ (from the right) close in on each other. At each step one of them moves inward, so the combined distance $r - l$ decreases by at least $1$ per iteration. Starting from $n - 1$ , the loop runs at most $n - 1$ times — $\Theta(n)$ . The invariant depends on the problem (e.g., 'the answer, if any, involves some $l' \ge l$ and $r' \le r$ ').

Example:

Given a sorted array [-4, -1, 0, 3, 10], return a new array of each element squared, sorted in non-decreasing order.

Blogs

Two Pointers Technique — GeeksforGeeks Two Pointers — USACO Guide

Definition

In-place deduplication of a sorted array rewrites its prefix so that nums[0..k-1] contains each distinct value exactly once, in sorted order, and returns k. Elements beyond index k-1 are left unspecified. A read pointer and a write pointer achieve this in a single pass, using O(n) time and O(1) extra space.

In this topic

1In-Place Deduplication with Two Pointers
2Allow At Most K Duplicates

1 of 2

In-Place Deduplication with Two Pointers

Because the array is sorted, duplicates form contiguous runs, so deciding whether nums[fast] is new needs only one comparison, against the last kept value nums[slow]. Keep slow on the last element of the unique prefix, starting at index 0, and let fast scan from index 1. When nums[fast] differs from nums[slow], increment slow and copy nums[fast] there; otherwise skip it. The invariant is that nums[0..slow] holds every distinct value seen so far, once each, so the answer is slow + 1. The method fails silently on unsorted input: [1, 2, 1] keeps all three values, because the two equal elements are not adjacent.

Mathematical Intuition

Maintain the invariant $a[0..w-1]$ is the deduplicated prefix. Read pointer $r$ scans the array; whenever $a[r] \ne a[w-1]$ , copy $a[r]$ to $a[w]$ and increment $w$ . Each index is touched $O(1)$ times so total work is $\Theta(n)$ . Space is $O(1)$ because writing happens in-place — the overwritten cells are never revisited by $r$ .

Example:

Remove duplicates in-place from sorted array [0, 0, 1, 1, 1, 2, 2, 3, 3, 4] and return the new length.

2 of 2

Allow At Most K Duplicates

A generalization of the deduplication problem: allow each value to appear at most k times instead of just once. The trick is to compare the fast pointer not with slow, but with the element k positions before slow. If nums[fast] != nums[slow - k + 1], the element can be added. For k=2, compare with nums[slow - 1]. This elegant modification handles any duplicate threshold with the same O(n) time and O(1) space.

Mathematical Intuition

Generalise the invariant: $a[0..w-1]$ contains each distinct element at most $k$ times. The decision 'should $a[r]$ be kept?' reduces to comparing with $a[w-k]$ : if different (or $w < k$ ), keep it. This preserves $\Theta(n)$ time and $O(1)$ space, and reduces to the standard dedup when $k = 1$ .

Example:

Remove duplicates from sorted array [1, 1, 1, 2, 2, 3] such that each element appears at most twice. Return the new length.

Blogs

Remove Duplicates from Sorted Array — NeetCode Remove Duplicates II — LeetCode Editorial

Definition

Two Sum Sorted asks for indices i < j in a sorted array such that nums[i] + nums[j] equals a target. Opposite-direction pointers start at i = 0 and j = n - 1, moving i right when the sum is too small and j left when it is too large. The method runs in O(n) time with O(1) extra space and never skips a valid pair.

In this topic

1Two Sum with Opposite Pointers
2Three Sum Reduction

1 of 2

Two Sum with Opposite Pointers

Place one pointer at the start and one at the end of the sorted array. Compute their sum. If the sum equals the target, you found the pair. If the sum is too small, move the left pointer right to increase it. If the sum is too large, move the right pointer left to decrease it. Each step eliminates one pointer position, guaranteeing termination in at most n steps. This gives O(n) time and O(1) space.

Mathematical Intuition

On a sorted array, define $s = a[l] + a[r]$ . If $s < \text{target}$ , increase $l$ (only way to grow $s$ ); if $s > \text{target}$ , decrease $r$ . The key claim: pointers only move inward, and any pair discarded by a move cannot achieve the target. This gives $\Theta(n)$ time — strictly better than the $O(n \log n)$ of sort-then-hash for the sorted case.

Example:

Given sorted array [2, 7, 11, 15] and target 9, return the indices of the two numbers that add up to the target.

2 of 2

Three Sum Reduction

The three-sum problem (find three numbers that sum to zero) reduces to two-sum sorted. Sort the array, then for each element nums[i], use two pointers on the remaining subarray to find a pair summing to -nums[i]. Skip duplicate values of i to avoid duplicate triplets. The total time is O(n^2): O(n) for the outer loop times O(n) for each two-pointer scan. This is optimal since there can be O(n^2) valid triplets.

Mathematical Intuition

3-sum reduces to $n$ calls of 2-sum: fix $a[i]$ , solve 2-sum for target $-a[i]$ on $a[i+1..]$ . With sorting ( $\Theta(n \log n)$ ) and $n$ linear passes ( $\Theta(n^2)$ ), total is $\Theta(n^2)$ . Lower bound: 3-sum is conjectured to require $\Omega(n^{2 - o(1)})$ time, so $\Theta(n^2)$ is believed optimal. The same pattern extends $k$ -sum to $\Theta(n^{k-1})$ .

Example:

Given [-1, 0, 1, 2, -1, -4], find all unique triplets that sum to 0.

Papers

Gajentaan, A. & Overmars, M. H. — On a Class of O(n^2) Problems in Computational Geometry (1995, Computational Geometry)Grønlund, A. & Pettie, S. — Threesomes, Degenerates, and Love Triangles (2014, FOCS)

Blogs

Two Sum II — NeetCode 3Sum — NeetCode

Definition

A string s of length n is a palindrome if s[i] equals s[n-1-i] for every index i < n/2. The two-pointer check compares s[left] with s[right], starting from the two ends, and moves both pointers inward after each match. It stops at the first mismatch, giving O(n) time in the worst case and O(1) extra space.

In this topic

1Basic Palindrome Check with Two Pointers
2Valid Palindrome with At Most One Removal

1 of 2

Basic Palindrome Check with Two Pointers

Place a left pointer at the start and a right pointer at the end of the string. Compare characters at both positions. If they match, move both pointers inward. If they differ, the string is not a palindrome. For case-insensitive checks, convert both characters to lowercase before comparing. To skip non-alphanumeric characters, advance the pointer past them before each comparison. The loop runs while left < right, giving O(n) time and O(1) space.

Mathematical Intuition

A string $s$ is a palindrome iff $s[i] = s[n-1-i]$ for all $0 \le i < n/2$ . Two pointers $l = 0, r = n-1$ compare in parallel, advancing inward when matched, failing on mismatch. Time is $\Theta(n)$ in the worst case, space $O(1)$ , and early termination makes the best case $O(1)$ .

Example:

Determine if "A man, a plan, a canal: Panama" is a valid palindrome, considering only alphanumeric characters and ignoring case.

2 of 2

Valid Palindrome with At Most One Removal

Some inputs are one typo away from a palindrome, and the question becomes whether deleting at most one character fixes them. Run the normal inward scan. At the first mismatch, at positions left and right, one of those two characters must be the deleted one, because every pair outside them already matches. So test the two remaining ranges, s[left+1..right] and s[left..right-1], with a plain palindrome check that allows no further deletions. If either passes, the answer is True. Each check is one linear scan, so the total stays O(n). Allowing unlimited deletions would instead branch at every mismatch and grow exponentially.

Mathematical Intuition

On mismatch at $(l, r)$ , the answer is 'yes' iff $s[l+1..r]$ or $s[l..r-1]$ is a palindrome — exactly one of the two characters must be the odd one out. This is a constant number of recursive palindrome checks, each $\Theta(n)$ , so the total remains $\Theta(n)$ . The bound 'at most one removal' prevents an exponential branching tree.

Example:

Can "abca" become a palindrome by removing at most one character?

Papers

Manacher, G. — A New Linear-Time On-Line Algorithm for Finding the Smallest Initial Palindrome of a String (1975, Journal of the ACM)

Blogs

Valid Palindrome — NeetCode Valid Palindrome II — LeetCode Editorial

Definition

A fixed-size sliding window is a contiguous range nums[i..i+k-1] of exactly k elements that advances one index at a time across an array of length n. Its aggregate is updated incrementally, adding the entering element and removing the leaving one, so all n - k + 1 windows are processed in O(n) total instead of O(nk).

In this topic

1Maximum Sum Subarray of Size K
2Sliding Window with Auxiliary Data Structures

1 of 2

Maximum Sum Subarray of Size K

Recomputing every window's sum from scratch costs k additions per window, O(nk) overall. Instead, compute the first window's sum once, then slide: the sum of the window starting at i + 1 equals the previous sum plus nums[i + k] minus nums[i]. Track the largest sum seen. Each slide is O(1), so the whole scan is O(n) with O(1) extra space. The subtraction step is the crux. It works for sums, counts, and averages, which can be undone, but not for a maximum, because removing the old maximum leaves no record of the runner-up. Also guard against k > n, where no window exists.

Mathematical Intuition

Compute $s_0 = a[0] + \dots + a[k-1]$ , then for each step add $a[i+k]$ and subtract $a[i]$ — an $O(1)$ update. Total $\Theta(n)$ time and $O(1)$ space. This is a telescoping sum: instead of recomputing $k$ terms, cache the running total and apply a delta of size $2$ per shift.

Example:

Find the maximum sum of any subarray of size 3 in [2, 1, 5, 1, 3, 2].

2 of 2

Sliding Window with Auxiliary Data Structures

Some fixed-window problems require more than a running sum. For example, counting distinct elements in each window of size k needs a hash map (frequency counter). When an element enters the window, increment its count; when one leaves, decrement it (and remove if count hits zero). The number of keys in the map gives the distinct count. Similarly, finding the maximum in each window can use a deque (monotonic queue) for O(n) amortized time.

Mathematical Intuition

To track properties like 'distinct count' or 'max in window' under $O(1)$ updates, pair the window with a hash map or a monotonic deque. Hash map: incrementing a counter on add and decrementing on remove gives $O(1)$ amortised per step. Monotonic deque: maintains window maxima in $\Theta(n)$ total because each element is pushed and popped at most once.

Example:

Count the number of distinct elements in each window of size 3 for array [1, 2, 1, 3, 4, 2, 3].

Papers

Lemire, D. — Streaming Maximum-Minimum Filter Using No More than Three Comparisons per Element (2006, Nordic Journal of Computing)

Blogs

Sliding Window Technique — GeeksforGeeks Maximum Average Subarray I — LeetCode Editorial

Definition

A variable-size sliding window keeps a range [left, right] whose length adapts to a constraint. The right pointer extends it one element per step, and the left pointer advances only to restore or exploit validity. When validity is monotonic in the window's extent, both pointers move at most n times, so the longest or shortest qualifying subarray is found in O(n).

In this topic

1Longest Window Pattern (Expand Until Invalid)
2Shortest Window Pattern (Shrink After Valid)

1 of 2

Longest Window Pattern (Expand Until Invalid)

For 'find the longest subarray with at most K distinct elements' type problems, expand the right pointer one element at a time, updating window state. When the constraint is violated (e.g., more than K distinct elements), shrink from the left until the constraint is restored. The answer is the maximum value of (right - left + 1) seen during the process. The key insight: each pointer moves at most n times total, so despite the nested loops, the total time is O(n).

Mathematical Intuition

Grow $r$ greedily; when the window becomes invalid, shrink $l$ until it is valid again. The total is $\Theta(n)$ because each index is touched at most twice (once by $r$ , once by $l$ ). Correctness: the optimal longest valid window must end at some $r$ , and for each $r$ the smallest valid $l$ is monotone non-decreasing — so a single-pass two-pointer sweep finds the optimum.

Example:

Find the length of the longest substring with at most 2 distinct characters in 'eceba'.

2 of 2

Shortest Window Pattern (Shrink After Valid)

For 'find the shortest subarray whose sum is at least target' type problems, expand right to grow the window sum. Once the sum meets or exceeds the target, the window is valid --- record its length and shrink from the left to try to find a shorter valid window. Keep shrinking while the window remains valid. The answer is the minimum length recorded. This pattern also handles 'minimum window substring' problems where you shrink after satisfying all required characters.

Mathematical Intuition

Expand $r$ until the window is valid, then shrink $l$ as long as it remains valid, recording the min length. Same $\Theta(n)$ bound. The key invariant is that any shorter valid window contained in $[l, r]$ must start at $l' > l$ , so moving $l$ only ever discards longer (suboptimal) candidates.

Example:

Find the length of the shortest subarray with sum >= 7 in [2, 3, 1, 2, 4, 3].

Blogs

Longest Substring Without Repeating Characters — NeetCode Minimum Window Substring — NeetCode

Definition

The prefix sum array of nums has length n + 1, with P[0] = 0 and P[i] = nums[0] + ... + nums[i-1]. The sum of the inclusive range nums[l..r] then equals P[r+1] - P[l]. Building P takes O(n) time, and every range-sum query afterwards takes O(1) time.

In this topic

1Building and Using Prefix Sums
2Subarray Sum Equals K with Prefix Sum + Hash Map

1 of 2

Building and Using Prefix Sums

Answering many range-sum queries with a loop is wasteful, because overlapping ranges repeat the same additions. Build an array P of length n + 1 with P[0] = 0 and P[i + 1] = P[i] + nums[i], so P[i] is the total of the first i elements. The sum of nums[l..r] inclusive is P[r + 1] - P[l]: P[r + 1] covers indices 0 through r, and subtracting P[l] cancels indices 0 through l - 1. The leading zero lets ranges starting at index 0 use the same formula. The classic bug, P[r] - P[l], drops nums[r]. Frequent updates call for a Fenwick tree instead.

Mathematical Intuition

Define $P[i] = a[0] + a[1] + \dots + a[i-1]$ with $P[0] = 0$ . Then $a[l] + \dots + a[r] = P[r+1] - P[l]$ in $O(1)$ . Preprocessing is $\Theta(n)$ and each query is $O(1)$ , so $q$ queries cost $\Theta(n + q)$ versus $\Theta(nq)$ naïvely — a huge win when $q$ is large.

Example:

Given nums = [1, 2, 3, 4, 5], answer these range sum queries: sum(0..2), sum(1..3), sum(2..4).

2 of 2

Subarray Sum Equals K with Prefix Sum + Hash Map

To count subarrays with sum exactly k, combine prefix sums with a hash map. As you compute prefix sums left to right, a subarray ending at index j with sum k means prefix[j+1] - prefix[i] = k for some i, which means prefix[i] = prefix[j+1] - k. So at each step, check how many previous prefix sums equal (current_prefix - k). Store prefix sum frequencies in a hash map for O(1) lookup. This solves the problem in O(n) time and O(n) space.

Mathematical Intuition

The number of subarrays with sum $= k$ equals $|\{(l, r) : P[r+1] - P[l] = k\}|$ . Rewriting as $P[l] = P[r+1] - k$ and maintaining a hash map from prefix sums to counts lets you count contributing $l$ 's for each $r$ in $O(1)$ . Total time $\Theta(n)$ , space $\Theta(n)$ — linear versus $\Theta(n^2)$ brute force.

Example:

Count the number of subarrays with sum equal to 3 in [1, 1, 1, 2, -1, 2].

Papers

Blelloch, G. E. — Prefix Sums and Their Applications (1993, in Synthesis of Parallel Algorithms)

Blogs

Prefix Sums — USACO Guide Subarray Sum Equals K — LeetCode Editorial

Definition

Floyd's cycle detection, also called the tortoise and hare algorithm, walks a sequence $x_0, f(x_0), f(f(x_0)), \ldots$ with a slow pointer taking one step and a fast pointer taking two. The pointers meet if and only if the sequence has a cycle. Restarting one pointer from the start and moving both one step at a time then finds the first node of the cycle, in O(1) space.

In this topic

1Tortoise and Hare Algorithm
2Finding Duplicates with Floyd's Algorithm

1 of 2

Tortoise and Hare Algorithm

Start slow and fast at the head and move them one and two nodes per step. If fast reaches null, there is no cycle. Otherwise both enter the cycle, where fast gains one node per step, so they meet within one lap. For the cycle's start, let d be the head-to-entry distance, L the cycle length, and m the meeting point's distance past the entry. Fast walked twice as far as slow, so d + m is a multiple of L, and d more steps from the meeting point land on the entry. Reset one pointer to the head and step both singly: they meet at the entry.

Mathematical Intuition

Let $\text{slow}$ advance by $1$ step and $\text{fast}$ by $2$ . If the list has a cycle of length $\mu$ starting at position $\lambda$ , they meet after at most $\lambda + \mu$ steps — because once both are inside the cycle, the relative speed is $1$ and fast catches slow in at most $\mu$ iterations. Total time $\Theta(n)$ , space $O(1)$ — no hash set needed.

Example:

Detect if a linked list has a cycle and find the node where the cycle begins.

2 of 2

Finding Duplicates with Floyd's Algorithm

Given an array of n+1 integers where each integer is between 1 and n, there must be at least one duplicate. Treat the array as a linked list where index i points to index nums[i]. A duplicate value means two indices point to the same 'node,' creating a cycle. Use Floyd's algorithm to find where the cycle begins --- that value is the duplicate number. This solves the problem in O(n) time and O(1) space without modifying the array.

Mathematical Intuition

Treat the array as a function $f(i) = a[i]$ . Because there are $n+1$ values in $[1, n]$ , $f$ has a cycle by the pigeonhole principle, and the duplicate is the cycle's entry point. Applying Floyd's algorithm twice (meet, then restart one pointer) finds the entry in $\Theta(n)$ time and $O(1)$ space — a striking improvement over $\Theta(n)$ time with $\Theta(n)$ space for the hash-set method.

Example:

Find the duplicate number in [1, 3, 4, 2, 2] using Floyd's algorithm (O(1) space, no array modification).

Papers

Brent, R. P. — An Improved Monte Carlo Factorization Algorithm (1980, BIT)Pollard, J. M. — A Monte Carlo Method for Factorization (1975, BIT)

Blogs

Tortoise and Hare Algorithm — CP Algorithms Linked List Cycle II — LeetCode Editorial

Two Pointers

In-Place Rewriting

Two Sum / Three Sum

Palindrome Checks

Fixed Window

Variable Window

Prefix Sums

Floyd's Tortoise & Hare

8 topics in this chapter

Same & Opposite Direction Pointers

Definition

In this topic

Same-Direction (Fast & Slow) Pointers

Opposite-Direction Pointers

Related Problems on PixelBank

Remove Duplicates

Definition

In this topic

In-Place Deduplication with Two Pointers

Allow At Most K Duplicates

Related Problems on PixelBank

Two Sum Sorted

Definition

In this topic

Two Sum with Opposite Pointers

Three Sum Reduction

Related Problems on PixelBank

Valid Palindrome

Definition

In this topic

Basic Palindrome Check with Two Pointers

Valid Palindrome with At Most One Removal

Related Problems on PixelBank

Fixed-Size Sliding Window

Definition

In this topic

Maximum Sum Subarray of Size K

Sliding Window with Auxiliary Data Structures

Related Problems on PixelBank

Longest & Shortest Window

Definition

In this topic

Longest Window Pattern (Expand Until Invalid)

Shortest Window Pattern (Shrink After Valid)

Related Problems on PixelBank

Prefix Sum

Definition

In this topic

Building and Using Prefix Sums

Subarray Sum Equals K with Prefix Sum + Hash Map

Related Problems on PixelBank

Cycle Detection (Floyd's)

Definition

In this topic

Tortoise and Hare Algorithm

Finding Duplicates with Floyd's Algorithm

Related Problems on PixelBank