W Code - Pattern-Based DSA Learning Platform

Bhanu Bisht

Template

Two Pointers Template: Pattern, Code & Cheat Sheet

The Two Pointers pattern is one of the most frequently tested coding interview patterns. Use two pointers converging or diverging on sorted arrays or linked lists. This template gives you a reusable code skeleton, pseudocode, and implementation in multiple languages so you can solve 18+ problems using this single mental model.

Difficulty: Easy | Time Complexity: O(n) | Space Complexity: O(1)

When to Use This Template

Use the Two Pointers template when you see these signals in a problem:

1.Pair sum — Problems asking to pair sum

2.Remove duplicates — Problems asking to remove duplicates

3.Container problems — Problems asking to container problems

Prerequisites: Arrays basics

Problem count on W Code: 18 problems across Easy, Medium, and Hard difficulty levels.

If the problem does not match these signals, consider alternative patterns.

Pseudocode Template

function twoPointerSolve(arr):
    left = 0
    right = length(arr) - 1
    
    while left < right:
        current = compute(arr[left], arr[right])
        
        if current == target:
            return result
        else if current < target:
            left += 1
        else:
            right -= 1
    
    return not_found

Python Implementation

python
def two_pointer_solve(arr: list, target: int) -> list:
    left, right = 0, len(arr) - 1
    
    while left < right:
        current = arr[left] + arr[right]
        if current == target:
            return [left, right]
        elif current < target:
            left += 1
        else:
            right -= 1
    
    return [-1, -1]

Java Implementation

java
public int[] twoPointerSolve(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++;
        else right--;
    }
    
    return new int[]{-1, -1};
}

C++ Implementation

cpp
vector<int> twoPointerSolve(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++;
        else right--;
    }
    
    return {-1, -1};
}

Variations & Adaptations

The Two Pointers pattern has several variations you should master:

Variation 1: Converging Pointers (sorted array)

This variation is useful when the problem specifically requires converging pointers (sorted array). Adapt the main template by modifying the core loop/recursion logic accordingly.

Variation 2: Fixed Separation (linked list)

This variation is useful when the problem specifically requires fixed separation (linked list). Adapt the main template by modifying the core loop/recursion logic accordingly.

Variation 3: Expanding from Center (palindrome)

This variation is useful when the problem specifically requires expanding from center (palindrome). Adapt the main template by modifying the core loop/recursion logic accordingly.

Variation 4: In-place Modification (remove duplicates)

This variation is useful when the problem specifically requires in-place modification (remove duplicates). Adapt the main template by modifying the core loop/recursion logic accordingly.

Common Mistakes & Edge Cases

When implementing Two Pointers, watch out for:

1.Off-by-one errors — Carefully handle boundary conditions in loops

2.Missing base case — Ensure recursion terminates properly

3.Integer overflow — Use appropriate data types for large inputs

4.Empty input — Handle null/empty arrays, strings, or graphs

5.Single element — Test with minimal inputs

Edge cases to always test:

•Empty input → expected output

•Single element → correct result

•All same elements → no infinite loop

•Maximum constraints → within time limit

Step-by-Step Problem Solving Guide

1.Identify the pattern: Does the problem involve Pair sum, Remove duplicates, Container problems?

2.Choose the template: Select the variation from above that best fits

3.Define variables: Map problem-specific entities to template variables

4.Implement the core logic: Fill in the template skeleton

5.Handle edge cases: Add boundary checks

6.Verify with examples: Trace through sample inputs

7.Analyze complexity: Confirm O(n) time and O(1) space

Frequently Asked Questions

What problems can I solve with the Two Pointers template?

The Two Pointers template applies to 18+ problems including: Pair sum, Remove duplicates, Container problems. Look for problems that involve use two pointers converging or diverging on sorted arrays or linked lists..

What is the time complexity of Two Pointers?

The typical time complexity is O(n) with space complexity of O(1). Some variations may differ.

What should I learn before Two Pointers?

Prerequisites include: Arrays basics. Make sure you are comfortable with these concepts first.

How do I recognize a Two Pointers problem in an interview?

Key signals: the problem involves pair sum; the problem involves remove duplicates; the problem involves container problems. Practice identifying these cues by solving at least 10 problems using this pattern.

Practice 18+ Two Pointers problems on W Code with instant feedback and AI-powered hints. Start your free practice now!

Start Learning Free