Two Pointers: Code Templates in 6 Languages

Coding Patterns - Guide to 30 Core Algorithm Patterns

Two Pointers: Opposite and Same Direction with Examples

If you have not read the concept guide yet, start there for the intuition and the complexity analysis. This page gives you the code you can memorize and adapt during an interview. The main template runs in

O(N)

time with

O(1)

extra space, and each variation notes where its cost differs.

Main Template: Opposite Direction (Pair Search)

Two pointers start at opposite ends of a sorted array and close in on each other. Each comparison either finds the answer or rules out one end of the remaining range, which is why the loop is linear.

Use this for Two Sum II - Input Array Is Sorted .

function twoPointersPairSum(arr, target) {
    let left = 0;
    let right = arr.length - 1;

    while (left < right) {
        const sum = arr[left] + arr[right];

        if (sum === target) {
            return [left, right];
        } else if (sum < target) {
            // A sorted array only gets larger to the right,
            // so a bigger sum can only come from the left side.
            left++;
        } else {
            right--;
        }
    }
    return [-1, -1];
}

def two_pointers_pair_sum(arr: List[int], target: int) -> List[int]:
    left, right = 0, len(arr) - 1

    while left < right:
        total = arr[left] + arr[right]

        if total == target:
            return [left, right]
        elif total < target:
            # The sum is too small. Moving the left pointer up
            # is the only way to increase it in a sorted array.
            left += 1
        else:
            right -= 1

    return [-1, -1]

public int[] twoPointersPairSum(int[] arr, int target) {
    int left = 0, right = arr.length - 1;

    while (left < right) {
        int sum = arr[left] + arr[right];

        if (sum == target) {
            return new int[]{left, right};
        } else if (sum < target) {
            left++;  // a larger sum needs a larger left value
        } else {
            right--; // a smaller sum needs a smaller right value
        }
    }
    return new int[]{-1, -1};
}

vector<int> twoPointersPairSum(vector<int>& arr, int target) {
    int left = 0, right = arr.size() - 1;

    while (left < right) {
        int sum = arr[left] + arr[right];

        if (sum == target) {
            return {left, right};
        } else if (sum < target) {
            left++;  // sorted order means larger values sit to the right
        } else {
            right--;
        }
    }
    return {-1, -1};
}

func twoPointersPairSum(arr []int, target int) []int {
    left, right := 0, len(arr)-1

    for left < right {
        sum := arr[left] + arr[right]

        if sum == target {
            return []int{left, right}
        } else if sum < target {
            left++ // the array is sorted, so left++ is the only way up
        } else {
            right--
        }
    }
    return []int{-1, -1}
}

Templates only help if you can recall them without staring at the screen. Turn these snippets into flashcards for daily mobile review.

Code Breakdown

Key Variables

left and right: the two unsettled ends of the remaining range. Everything left of left and right of right has already been ruled out.
sum: the comparison value that decides which pointer moves. The decision rule is what carries the sorted-order guarantee, so keep it on one line and readable.

Visual Mechanism

    graph TD
    I["left = 0, right = n - 1"] --> C{"left < right?"}
    C -->|Yes| S["Compute arr[left] + arr[right]"]
    S --> T{"Sum vs target?"}
    T -->|"Equal"| F["Return indices"]
    T -->|"Too small"| L["left++"]
    T -->|"Too large"| R["right--"]
    L --> C
    R --> C
    C -->|No| N["Return not found"]

Critical Sections

The initialization pins the pointers to the two ends. Starting anywhere else would skip candidates, and the sorted guarantee only holds while the range between the pointers is the set of elements that could still form a pair.

The compare-and-move step is the heart of the template. When the sum is too small, every pair that includes arr[left] with any element to its right is also too small, because all of them use a value smaller than the current right pointer. Advancing left discards that whole group. The symmetric argument discards every pair containing arr[right] when the sum is too large. One comparison eliminates a group, not a single element, and that is where the linear bound comes from.

The termination condition left < right stops the loop before the pointers can land on the same index. With <=, a target equal to twice one element would let a single index report itself as a valid pair.

Variations

1. Same Direction (Remove Duplicates)

Use this when the input is sorted and you must rewrite it in place, keeping each unique value once. The fast pointer scans every element while slow marks where the next kept value belongs. The prefix before slow always holds the deduplicated result.

Use this for Remove Duplicates from Sorted Array .

Time

O(N)

| Space

O(1)

function removeDuplicates(nums) {
    if (nums.length === 0) return 0;

    let slow = 0; // where the next unique value will be written
    for (let fast = 1; fast < nums.length; fast++) {
        // fast found a value the kept prefix does not have yet.
        // Move the write position forward and place it there.
        if (nums[fast] !== nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

def remove_duplicates(nums: List[int]) -> int:
    if not nums:
        return 0

    slow = 0  # where the next unique value will be written
    for fast in range(1, len(nums)):
        # The scan found a value the kept prefix does not have.
        # Write it at the next position and extend the prefix.
        if nums[fast] != nums[slow]:
            slow += 1
            nums[slow] = nums[fast]
    return slow + 1

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;

    int slow = 0; // where the next unique value will be written
    for (int fast = 1; fast < nums.length; fast++) {
        if (nums[fast] != nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

int removeDuplicates(vector<int>& nums) {
    if (nums.empty()) return 0;

    int slow = 0; // where the next unique value will be written
    for (int fast = 1; fast < nums.size(); fast++) {
        if (nums[fast] != nums[slow]) {
            slow++;
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

func removeDuplicates(nums []int) int {
    if len(nums) == 0 { return 0 }

    slow := 0 // where the next unique value will be written
    for fast := 1; fast < len(nums); fast++ {
        if nums[fast] != nums[slow] {
            slow++
            nums[slow] = nums[fast]
        }
    }
    return slow + 1
}

def remove_duplicates(nums)
  return 0 if nums.empty?

  slow = 0 # where the next unique value will be written
  (1...nums.length).each do |fast|
    if nums[fast] != nums[slow]
      slow += 1
      nums[slow] = nums[fast]
    end
  end
  slow + 1
end

2. Fixed Pivot Plus Two Pointers (3Sum)

Use this when you need every triplet that satisfies a condition, not just one pair. Sort the array, fix one element as the pivot, then run the opposite direction pair search on the remaining range to the right of the pivot.

Use this for 3Sum .

Time

O(N^2)

| Space

O(1)

(besides the sort)

function threeSum(nums) {
    nums.sort((a, b) => a - b);
    const result = [];

    for (let i = 0; i < nums.length - 2; i++) {
        // The same pivot value produces the same triplets,
        // so skip it to keep the answer free of duplicates.
        if (i > 0 && nums[i] === nums[i - 1]) continue;

        let left = i + 1, right = nums.length - 1;
        while (left < right) {
            const sum = nums[i] + nums[left] + nums[right];
            if (sum === 0) {
                result.push([nums[i], nums[left], nums[right]]);
                // After a match, skip equal neighbors so the same
                // triplet is never recorded twice.
                while (left < right && nums[left] === nums[left + 1]) left++;
                while (left < right && nums[right] === nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    return result;
}

def three_sum(nums: List[int]) -> List[List[int]]:
    nums.sort()
    result = []

    for i in range(len(nums) - 2):
        # A repeated pivot can only reproduce triplets that
        # were already recorded, so skip it.
        if i > 0 and nums[i] == nums[i - 1]:
            continue

        left, right = i + 1, len(nums) - 1
        while left < right:
            total = nums[i] + nums[left] + nums[right]
            if total == 0:
                result.append([nums[i], nums[left], nums[right]])
                # Advance past equal neighbors to avoid
                # recording the same triplet twice.
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif total < 0:
                left += 1
            else:
                right -= 1

    return result

public List<List<Integer>> threeSum(int[] nums) {
    Arrays.sort(nums);
    List<List<Integer>> result = new ArrayList<>();

    for (int i = 0; i < nums.length - 2; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) continue;

        int left = i + 1, right = nums.length - 1;
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                result.add(Arrays.asList(nums[i], nums[left], nums[right]));
                // Skip equal neighbors so the same triplet
                // is not recorded twice.
                while (left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    return result;
}

vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(), nums.end());
    vector<vector<int>> result;

    for (int i = 0; i < (int)nums.size() - 2; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) continue;

        int left = i + 1, right = nums.size() - 1;
        while (left < right) {
            int sum = nums[i] + nums[left] + nums[right];
            if (sum == 0) {
                result.push_back({nums[i], nums[left], nums[right]});
                // Skip equal neighbors so the same triplet
                // is not recorded twice.
                while (left < right && nums[left] == nums[left + 1]) left++;
                while (left < right && nums[right] == nums[right - 1]) right--;
                left++;
                right--;
            } else if (sum < 0) {
                left++;
            } else {
                right--;
            }
        }
    }
    return result;
}

func threeSum(nums []int) [][]int {
    sort.Ints(nums)
    result := [][]int{}

    for i := 0; i < len(nums)-2; i++ {
        if i > 0 && nums[i] == nums[i-1] { continue }

        left, right := i+1, len(nums)-1
        for left < right {
            sum := nums[i] + nums[left] + nums[right]
            if sum == 0 {
                result = append(result, []int{nums[i], nums[left], nums[right]})
                // Advance past equal neighbors so the same
                // triplet is never recorded twice.
                for left < right && nums[left] == nums[left+1] { left++ }
                for left < right && nums[right] == nums[right-1] { right-- }
                left++
                right--
            } else if sum < 0 {
                left++
            } else {
                right--
            }
        }
    }
    return result
}

def three_sum(nums)
  nums.sort!
  result = []

  (0...nums.length - 2).each do |i|
    next if i > 0 && nums[i] == nums[i - 1]

    left, right = i + 1, nums.length - 1
    while left < right
      sum = nums[i] + nums[left] + nums[right]
      if sum == 0
        result << [nums[i], nums[left], nums[right]]
        # Skip equal neighbors so the same triplet
        # is never recorded twice.
        left += 1 while left < right && nums[left] == nums[left + 1]
        right -= 1 while left < right && nums[right] == nums[right - 1]
        left += 1
        right -= 1
      elsif sum < 0
        left += 1
      else
        right -= 1
      end
    end
  end
  result
end

Each variation above is a separate review card in the app. Drill them individually so you do not mix up the conditions under pressure.

Now head to the practice problems to apply these templates to real interview questions.

Now that you have the templates, the next step is application. Head to the practice problems or start reviewing these templates with spaced repetition .