Sorting Questions at Yelp: What to Expect

Sorting questions appear in roughly 25% of Yelp’s technical interviews (7 out of 27 total problems). This frequency isn’t accidental. Yelp’s core services—search, recommendations, and displaying business listings—are built on efficiently ordering massive datasets. Whether it’s ranking restaurants by proximity, sorting reviews by date or helpfulness, or filtering search results, the ability to quickly organize and retrieve ordered data is fundamental. Mastering sorting algorithms and, more importantly, the patterns that use sorting as a tool, is critical for passing their technical screens.

What to Expect — Types of Problems

You will rarely be asked to implement a raw sorting algorithm like quicksort from scratch. Instead, Yelp’s problems typically use sorting as a key step in the solution. Expect these categories:

1. Sorting as Pre-processing: Many array or string problems become tractable once the data is sorted. Finding duplicates, meeting time overlaps, or the “K closest points” classic are solved by sorting first.
2. Custom Comparison Sorting: You’ll often need to sort objects based on complex rules—e.g., sort businesses by distance, then rating, then name. This tests your ability to write correct comparator functions.
3. Interval Problems: A Yelp staple. Think of merging business operating hours or scheduling events. Sorting intervals by their start time is almost always the first step.
4. Two-Pointer Techniques on Sorted Data: Once an array is sorted, two-pointer or sliding window techniques become powerful for solving problems like “two-sum” or finding pairs with a certain property efficiently.

How to Prepare — Study Tips with One Code Example

Focus on the patterns, not the algorithms. Internalize that sorting an array of n elements often changes the time complexity baseline to O(n log n). Your goal is to recognize when sorting unlocks a simpler or optimal solution.

A key pattern is Sorting + Two-Pointer. This is ideal for problems involving pairs in an array. The brute-force approach is O(n²). By sorting first, we can use two pointers to find pairs in O(n log n) time.

Consider the classic Two Sum II problem (input array is sorted), but a Yelp variant might involve finding pairs of business IDs that sum to a target value. Here’s the pattern:

def find_pairs(nums, target):
    nums.sort()  # Key pre-processing step
    left, right = 0, len(nums) - 1
    pairs = []

    while left < right:
        current_sum = nums[left] + nums[right]
        if current_sum == target:
            pairs.append([nums[left], nums[right]])
            left += 1
            right -= 1
        elif current_sum < target:
            left += 1  # Need a larger sum
        else:
            right -= 1  # Need a smaller sum
    return pairs

Recommended Practice Order

1. Fundamentals: Ensure you understand how sorting affects time/space complexity. Practice writing custom comparators in your language of choice.
2. Core Patterns: Solve problems using Sorting + Two-Pointer and Sorting + Greedy approaches. Practice interval merging and insertion.
3. Yelp Context: Apply these patterns to business-oriented problems, like sorting reviews, merging business hours, or ranking search results.
4. Optimization: For each problem, ask: “Did sorting enable a better solution? What is the cost (O(n log n)) and benefit?”

Practice Sorting at Yelp