Two Pointers Questions at Swiggy: What to Expect

Two Pointers is a core algorithmic pattern that appears in 5 out of 41 coding questions at Swiggy. This 12% representation means you have a high probability of encountering it in your technical interview. For a company that operates at Swiggy's scale—optimizing delivery routes, managing real-time order assignments, and processing large datasets—efficient array and string manipulation is non-negotiable. The Two Pointers technique is prized for its ability to solve problems in linear O(n) time with constant O(1) extra space, making it ideal for performance-critical systems.

What to Expect — Types of Problems

Swiggy's Two Pointers questions typically fall into three categories, reflecting real-world engineering scenarios:

1. Sorted Array Pair Searches: Finding pairs or triplets that meet a condition (e.g., "two sum" in a sorted list, three sum, or pairs with a specific difference). This directly relates to tasks like matching delivery executives to orders based on proximity scores stored in sorted arrays.
2. In-Place Array Transformations: Removing duplicates, segregating elements (like moving all zeros to the end), or partitioning. This mirrors data sanitization and filtering for order lists or user data streams.
3. String Validity & Comparison: Checking for palindromes, subsequences, or string transformations (e.g., backspace string compare). This is applicable to validating user inputs, tracking order IDs, or comparing address strings.

Expect problems that test not just your ability to implement the pattern, but also to identify when it's the optimal tool.

How to Prepare — Study Tips with One Code Example

Master the fundamentals first. The core idea is using two indices (pointers) that traverse a data structure—often from opposite ends or at different speeds—to solve a problem in a single pass.

A critical pattern is the "Opposite Ends" Two Pointer used for problems like finding a pair sum in a sorted array. This is a classic because it reduces a potential O(n²) brute-force solution to O(n).

def two_sum_sorted(numbers, target):
    left, right = 0, len(numbers) - 1
    while left < right:
        current_sum = numbers[left] + numbers[right]
        if current_sum == target:
            return [left, right]  # Indices found
        elif current_sum < target:
            left += 1  # Need a larger sum
        else:  # current_sum > target
            right -= 1  # Need a smaller sum
    return []  # No pair found

Practice by writing this code from memory. Then, trace its execution with sample inputs to build intuition for how the pointers converge.

Recommended Practice Order

Build your competency systematically:

1. Foundation: Start with basic opposite-ends problems (Two Sum II, Valid Palindrome).
2. In-Place Operations: Move to problems requiring element swaps or overwrites (Remove Duplicates, Move Zeroes).
3. Complex Traversal: Tackle "slow and fast" pointer problems (Linked List Cycle) and sliding window variants.
4. Swiggy-Specific: Finally, solve problems tagged for Swiggy on platforms like CodeJeet to familiarize yourself with their exact problem style and constraints.

Focus on writing clean, bug-free code. In your interview, clearly communicate your thought process, starting with the brute-force approach before optimizing with the Two Pointers technique.

Practice Two Pointers at Swiggy