Two Pointers Questions at Yelp: What to Expect

Two Pointers is a core algorithmic pattern that appears in roughly 11% of Yelp's technical interview questions (3 out of 27). For a company that builds services around location data, reviews, and search, efficient array and string manipulation is non-negotiable. This pattern is directly applicable to problems involving sorted data, palindromes, or finding pairs that meet a condition—common tasks when filtering business results, validating user input, or comparing geographic data points. Mastering it demonstrates you can write optimized, clean solutions under interview constraints.

What to Expect — Types of Problems

At Yelp, Two Pointers questions typically fall into two categories. The first is the opposite-direction pointers pattern, used for problems where you work inwards from the ends of a sorted array or string. Classic examples include finding a pair of numbers that sum to a target, checking for a palindrome, or reversing a string in-place. The second is the fast-and-slow pointers pattern, often applied to linked list cycles, but also useful for problems where you need to maintain relative position while filtering or compressing data, such as removing duplicates from a sorted array.

Expect the problems to be framed in a practical context, like validating a search query, processing a list of coordinates, or cleaning user-generated text data. The underlying algorithm, however, will be the standard Two Pointers technique.

How to Prepare — Study Tips with One Code Example

Focus on the fundamentals. Start by ensuring you can implement the two main variants from memory. Practice on sorted arrays first, as this is the most common setup. Always ask: "Is the data sorted?" If not, sorting it might be the first step to enable the Two Pointers approach. For fast-and-slow pointer problems, diagram the pointer movement on a sample linked list to build intuition.

A key pattern to internalize is the opposite-direction two-sum solution. Here is the standard implementation for finding if a pair in a sorted array sums to a target.

def has_pair_with_sum(sorted_arr, target):
    left, right = 0, len(sorted_arr) - 1
    while left < right:
        current_sum = sorted_arr[left] + sorted_arr[right]
        if current_sum == target:
            return True
        elif current_sum < target:
            left += 1  # Need a larger sum
        else:
            right -= 1  # Need a smaller sum
    return False

Recommended Practice Order

Build competency in this sequence. First, solve classic opposite-direction problems: two-sum in a sorted array, valid palindrome, and container with most water. Second, practice fast-and-slow pointer problems: remove duplicates from sorted array and linked list cycle detection. Finally, combine the pattern with other concepts, such as using it within a sliding window or on a sorted matrix. This progression ensures you understand the basic mechanics before tackling more complex integrations.

Practice Two Pointers at Yelp