Uber Coding Questions 2025 - Interview Problems with Solutions

Uber Coding Questions - Complete Problem Set

Practice 25+ Uber coding interview questions with solutions. Uber focuses on geospatial problems and real-time systems.

Uber Interview Focus

Uber values: Geospatial algorithms, Real-time matching, Dynamic pricing, Scalable systems, Clean code.

Uber-Specific Problems

1. Find Nearest Drivers (K Closest Points)

Problem

Find k nearest drivers to a user’s location.

Input: drivers = [[1,3],[-2,2],[5,8],[0,1]], user = [0,0], k = 2
Output: [[-2,2],[0,1]]

Python

import heapq

def k_closest_drivers(drivers, user, k):
    def distance(point):
        return (point[0] - user[0])**2 + (point[1] - user[1])**2

    # Max heap of size k
    heap = []
    for driver in drivers:
        dist = distance(driver)
        heapq.heappush(heap, (-dist, driver))
        if len(heap) > k:
            heapq.heappop(heap)

    return [driver for _, driver in heap]

2. Ride Matching (Bipartite Matching)

Problem

Match riders to drivers optimally.

Python

def optimal_matching(riders, drivers):
    """
    Hungarian algorithm for optimal assignment
    Simplified greedy version shown here
    """
    n = len(riders)
    m = len(drivers)
    assignments = []
    used_drivers = set()

    for rider in riders:
        best_driver = None
        best_distance = float('inf')

        for j, driver in enumerate(drivers):
            if j not in used_drivers:
                dist = abs(rider[0] - driver[0]) + abs(rider[1] - driver[1])
                if dist < best_distance:
                    best_distance = dist
                    best_driver = j

        if best_driver is not None:
            assignments.append((rider, drivers[best_driver]))
            used_drivers.add(best_driver)

    return assignments

3. Surge Pricing (Dynamic Programming)

Problem

Calculate optimal surge multiplier based on supply/demand.

Python

def calculate_surge(demand, supply, base_price):
    """
    Simple surge pricing model
    """
    if supply == 0:
        return base_price * 5.0  # Max surge

    ratio = demand / supply

    if ratio <= 1:
        return base_price
    elif ratio <= 2:
        return base_price * 1.5
    elif ratio <= 3:
        return base_price * 2.0
    elif ratio <= 5:
        return base_price * 3.0
    else:
        return base_price * min(5.0, ratio)

4. Route Optimization (Dijkstra’s)

Python

import heapq
from collections import defaultdict

def shortest_path(graph, start, end):
    distances = {start: 0}
    heap = [(0, start)]
    parent = {start: None}

    while heap:
        dist, node = heapq.heappop(heap)

        if node == end:
            # Reconstruct path
            path = []
            while node:
                path.append(node)
                node = parent[node]
            return path[::-1], dist

        if dist > distances.get(node, float('inf')):
            continue

        for neighbor, weight in graph[node]:
            new_dist = dist + weight
            if new_dist < distances.get(neighbor, float('inf')):
                distances[neighbor] = new_dist
                parent[neighbor] = node
                heapq.heappush(heap, (new_dist, neighbor))

    return None, float('inf')

5. ETA Prediction

Problem

Predict arrival time considering traffic.

Python

def predict_eta(distance, base_speed, traffic_factor, stops):
    """
    ETA = (distance / speed_with_traffic) + stop_time
    """
    adjusted_speed = base_speed * traffic_factor
    travel_time = distance / adjusted_speed

    # Average stop time
    stop_time = stops * 0.5  # 30 seconds per stop

    return travel_time + stop_time

def eta_with_confidence(distance, historical_data):
    """
    Return ETA with confidence interval
    """
    import statistics

    etas = [predict_eta(distance, d['speed'], d['traffic'], d['stops'])
            for d in historical_data]

    mean_eta = statistics.mean(etas)
    std_eta = statistics.stdev(etas) if len(etas) > 1 else 0

    return {
        'eta': mean_eta,
        'lower': mean_eta - 2 * std_eta,
        'upper': mean_eta + 2 * std_eta
    }

Standard DSA Problems

6. LRU Cache

Python

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity

    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]

    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)

7. Word Ladder

Python

from collections import deque

def ladder_length(begin_word, end_word, word_list):
    word_set = set(word_list)
    if end_word not in word_set:
        return 0

    queue = deque([(begin_word, 1)])
    visited = {begin_word}

    while queue:
        word, length = queue.popleft()

        for i in range(len(word)):
            for c in 'abcdefghijklmnopqrstuvwxyz':
                new_word = word[:i] + c + word[i+1:]

                if new_word == end_word:
                    return length + 1

                if new_word in word_set and new_word not in visited:
                    visited.add(new_word)
                    queue.append((new_word, length + 1))

    return 0

8. Meeting Rooms II

Python

import heapq

def min_meeting_rooms(intervals):
    if not intervals:
        return 0

    intervals.sort(key=lambda x: x[0])
    heap = []

    for start, end in intervals:
        if heap and heap[0] <= start:
            heapq.heappop(heap)
        heapq.heappush(heap, end)

    return len(heap)

9. Serialize/Deserialize Binary Tree

Python

class Codec:
    def serialize(self, root):
        def dfs(node):
            if not node:
                return ['null']
            return [str(node.val)] + dfs(node.left) + dfs(node.right)
        return ','.join(dfs(root))

    def deserialize(self, data):
        nodes = iter(data.split(','))

        def dfs():
            val = next(nodes)
            if val == 'null':
                return None
            node = TreeNode(int(val))
            node.left = dfs()
            node.right = dfs()
            return node

        return dfs()

10. Maximum Subarray

Python

def max_subarray(nums):
    max_sum = current_sum = nums[0]
    for num in nums[1:]:
        current_sum = max(num, current_sum + num)
        max_sum = max(max_sum, current_sum)
    return max_sum

Related Resources

Uber Interview Experience

Real interview experiences. Read Experiences →

Uber Preparation Guide

Complete preparation strategy. View Guide →

---

Practice geospatial + standard DSA for Uber!

Last updated: February 2026