Two Pointers Questions at Zepto: What to Expect

Two Pointers isn't just another algorithm pattern for Zepto's technical interviews—it's a core efficiency tool for a company that optimizes 10-minute grocery deliveries. Their platform constantly processes real-time data: merging delivery routes, validating time slots, or finding the closest warehouse to a customer cluster. Solving these problems with brute force O(n²) loops is unacceptable when scaling to millions of orders. The Two Pointers technique, which often achieves O(n) time with O(1) space, directly mirrors the efficient, scalable thinking Zepto engineers need daily. With 4 out of their 28 tagged problems focusing on this pattern, mastering it is non-negotiable for candidates.

What to Expect — Types of Problems

Zepto's Two Pointers questions typically fall into two categories, both emphasizing practical, data-centric operations.

1. Sorted Array Pair Searches: This is the most common variant. You'll be given a sorted array (of order values, delivery distances, or time intervals) and tasked with finding a pair or set of elements meeting a specific condition, like two orders whose combined value matches a target voucher amount or three delivery IDs that sum to zero. The classic "Two Sum II - Input Array Is Sorted" is a fundamental building block here.

2. In-Place Array Manipulation: This tests your ability to manage data with minimal memory overhead—a key concern in high-throughput systems. Problems involve removing duplicates from a sorted list of customer IDs, segregating order types (e.g., "express" vs. "standard"), or merging two sorted lists of delivery assignments into one. The pointers are used to overwrite elements in place, avoiding the cost of creating new data structures.

You will not see complex linked list cycle detection here; Zepto's focus is squarely on array-based problems that model efficient data processing.

How to Prepare — Study Tips with One Code Example

Start by deeply understanding the core mechanic: using two indices (often one at the start and one at the end of a sorted array) to traverse and make decisions in a single pass. Trace the logic manually. Then, practice identifying the pattern: if a problem involves a sorted array and asks for finding pairs, triplets, or filtering elements, Two Pointers is your first suspicion.

Internalize this classic "pair with target sum" pattern, as it's the foundation for more complex problems like three-sum.

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 + 1, right + 1]  # 1-based index
        elif current_sum < target:
            left += 1  # Need a larger sum
        else:
            right -= 1  # Need a smaller sum
    return []  # No solution

Recommended Practice Order

Build competence incrementally. Do not jump to Zepto's most complex problems first.

1. Foundation: Solve "Two Sum II - Input Array Is Sorted" and "Remove Duplicates from Sorted Array" until you can write the code from memory. They cement the two main problem types.
2. Variants: Move to "3Sum" and "Container With Most Water." These test your ability to adapt the basic two-pointer logic to more complex conditions (triplets, area calculation).
3. Zepto-Specific: Finally, tackle the actual Two Pointers problems in Zepto's question bank. You'll now have the pattern recognition and coding muscle memory to dissect their specific constraints and edge cases.

Practice Two Pointers at Zepto