Filter Restaurants by Vegan-Friendly, Price and Distance

Filter Restaurants by Vegan-Friendly, Price and Distance - Problem

Array Sorting Medium

You're building a restaurant discovery app and need to implement a smart filtering system! 🍴

Given an array of restaurants where each restaurants[i] = [id, rating, veganFriendly, price, distance], your task is to filter restaurants based on three criteria:

Vegan Filter: If veganFriendly = 1, only include vegan restaurants. If veganFriendly = 0, include all restaurants
Price Filter: Only include restaurants where price ≤ maxPrice
Distance Filter: Only include restaurants where distance ≤ maxDistance

Goal: Return the restaurant IDs after filtering, sorted by:

Rating (highest first) 📈
For same ratings: ID (highest first) 🔢

Note: veganFriendly values are 1 for true and 0 for false.

Input & Output

example_1.py — Basic Filtering

$ Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]] veganFriendly = 1, maxPrice = 50, maxDistance = 10

› Output: [3,1,5]

💡 Note: Filtering for vegan restaurants (veganFriendly=1): restaurants 1,3,5 pass. After sorting by rating desc, then ID desc: restaurant 3 (rating 8), restaurant 1 (rating 4), restaurant 5 (rating 1).

example_2.py — No Vegan Filter

$ Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]] veganFriendly = 0, maxPrice = 50, maxDistance = 10

› Output: [4,3,2,1,5]

💡 Note: No vegan filter (veganFriendly=0): all restaurants within price/distance limits pass. Sorted by rating: 4(10), 3(8), 2(8), 1(4), 5(1). For same rating 8, ID 3>2.

example_3.py — Strict Distance Filter

$ Input: restaurants = [[1,4,1,40,10],[2,8,0,50,5],[3,8,1,30,4],[4,10,0,10,3],[5,1,1,15,1]] veganFriendly = 0, maxPrice = 30, maxDistance = 3

› Output: [4,5]

💡 Note: Strict filters: only restaurants 4 (price=10, distance=3) and 5 (price=15, distance=1) qualify. Sorted by rating: 4(10), 5(1).

Constraints

1 ≤ restaurants.length ≤ 10⁴
restaurants[i].length == 5
1 ≤ id_i, rating_i, price_i, distance_i ≤ 10⁵
1 ≤ maxPrice, maxDistance ≤ 10⁵
veganFriendly_i and veganFriendly are 0 or 1
All values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Apply Filters

Check each restaurant against vegan, price, and distance criteria in a single pass

Collect Results

Gather all restaurants that meet the filtering criteria

Smart Sorting

Sort by rating (best first), then by ID (highest first) for ties

Return IDs

Extract and return only the restaurant IDs in the final ranked order

Key Takeaway

🎯 Key Insight: This problem combines filtering with custom sorting. The optimal approach uses single-pass filtering (O(n)) followed by efficient sorting (O(n log n)), making it perfect for real-world recommendation systems that need to quickly process user preferences and return ranked results.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal approach uses single-pass filtering combined with efficient sorting. Filter restaurants by checking all three conditions simultaneously (O(n)), then sort by rating descending and ID descending (O(n log n)). The overall complexity is O(n log n) dominated by sorting, which is optimal for this problem since we need sorted output.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Filter + Sort)	O(n log n)	O(n)	Filter restaurants one by one, then sort the results
Optimized Filter + Sort	O(n log n)	O(n)	Single pass filtering with efficient sorting

Brute Force (Filter + Sort) — Algorithm Steps

Iterate through each restaurant
Check vegan filter condition
Check price filter condition
Check distance filter condition
If all filters pass, add to results
Sort results by rating (desc), then ID (desc)

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Filters

Go through each restaurant and check all three filter conditions

Collect Valid

Add restaurants that pass all filters to result list

Sort Results

Sort by rating (highest first), then by ID (highest first)

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
    int *arrA = *(int**)a;
    int *arrB = *(int**)b;
    
    // Sort by rating (desc), then by ID (desc)
    if (arrA[1] != arrB[1]) return arrB[1] - arrA[1];
    return arrB[0] - arrA[0];
}

int* filterRestaurants(int** restaurants, int restaurantsSize, int* restaurantsColSize, 
                      int veganFriendly, int maxPrice, int maxDistance, int* returnSize) {
    int** filtered = (int**)malloc(restaurantsSize * sizeof(int*));
    int filteredSize = 0;
    
    // Filter restaurants one by one
    for (int i = 0; i < restaurantsSize; i++) {
        int id = restaurants[i][0], rating = restaurants[i][1], vegan = restaurants[i][2];
        int price = restaurants[i][3], distance = restaurants[i][4];
        
        // Check each filter condition
        if (veganFriendly == 1 && vegan == 0) continue;
        if (price > maxPrice) continue;
        if (distance > maxDistance) continue;
        
        filtered[filteredSize++] = restaurants[i];
    }
    
    // Sort by rating (desc), then by ID (desc)
    qsort(filtered, filteredSize, sizeof(int*), compare);
    
    // Return only IDs
    int* result = (int*)malloc(filteredSize * sizeof(int));
    for (int i = 0; i < filteredSize; i++) {
        result[i] = filtered[i][0];
    }
    
    *returnSize = filteredSize;
    free(filtered);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) for filtering + O(n log n) for sorting, dominated by sorting

⚡ Linearithmic

Space Complexity

O(n)

Space for storing filtered results

⚡ Linearithmic Space

24.7K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Filter + Sort) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler