Uber Coding Round Questions 2026: Patterns + Solutions

Quick answer (updated 8 June 2026): Uber's coding rounds in 2026 test core DSA with a lean toward graphs, heaps, intervals, and dynamic programming, reflecting its routing, matching, and real-time systems. Difficulty is medium to hard, with clean code and clear reasoning expected. For most roles a design discussion follows. The patterns and frequencies below are compiled from 2023 to 2025 candidate reports, not an official syllabus, so use them to prioritise and confirm specifics in your assessment invite from the Uber careers portal.

Uber's coding rounds skew toward graph and real-time-systems flavoured problems, which makes sense for a company built on routing and matching. This guide gives you the repeating patterns, worked solutions, and a design primer.

Uber Coding Round Topics

Compiled from candidate reports across 2023 to 2025; relative frequency, not an official syllabus:

Relative frequencies from candidate aggregates (2023 to 2025), labelled approximate. Graphs, heaps, and intervals are notably common at Uber.

Worked Solution 1: Graphs (Dijkstra)

Problem: Given a weighted graph and a source, find the shortest distance to every node.

Approach: Dijkstra's algorithm with a min-heap, relaxing edges from the closest unsettled node.

import heapq

def dijkstra(graph, source, n):
    dist = [float('inf')] * n
    dist[source] = 0
    heap = [(0, source)]
    while heap:
        d, u = heapq.heappop(heap)
        if d > dist[u]:
            continue
        for v, w in graph[u]:
            if d + w < dist[v]:
                dist[v] = d + w
                heapq.heappush(heap, (dist[v], v))
    return dist

Complexity: O((V + E) log V) time. Routing and ETA problems map directly to shortest-path, which is why Uber probes Dijkstra and its variants often.

Worked Solution 2: Heaps (Merge K)

Problem: Merge k sorted lists into one sorted list.

Approach: Min-heap of the current head of each list; repeatedly pop the smallest and push its successor.

import heapq

def merge_k_lists(lists):
    heap = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    dummy = tail = ListNode(0)
    while heap:
        val, i, node = heapq.heappop(heap)
        tail.next = node
        tail = node
        if node.next:
            heapq.heappush(heap, (node.next.val, i, node.next))
    return dummy.next

Complexity: O(N log k) time where N is the total number of nodes. The index in the tuple breaks ties so nodes are never compared directly.

Worked Solution 3: Intervals

Problem: Given a new interval and a sorted list of non-overlapping intervals, insert it and merge as needed.

Approach: Add all intervals ending before the new one, merge all that overlap, then add the rest.

def insert_interval(intervals, new):
    result = []
    i, n = 0, len(intervals)
    while i < n and intervals[i][1] < new[0]:
        result.append(intervals[i])
        i += 1
    while i < n and intervals[i][0] <= new[1]:
        new[0] = min(new[0], intervals[i][0])
        new[1] = max(new[1], intervals[i][1])
        i += 1
    result.append(new)
    while i < n:
        result.append(intervals[i])
        i += 1
    return result

Complexity: O(n) time, O(n) space. Interval merging maps to scheduling and availability problems common in Uber's domain.

Worked Solution 4: Graphs (Topological Sort)

Problem: Given tasks with dependencies, return a valid order to complete them, or report a cycle.

Approach: Kahn's algorithm. Process zero-in-degree nodes; if you cannot process all, there is a cycle.

from collections import deque, defaultdict

def task_order(num_tasks, deps):
    graph = defaultdict(list)
    indeg = [0] * num_tasks
    for a, b in deps:
        graph[b].append(a)
        indeg[a] += 1
    q = deque(i for i in range(num_tasks) if indeg[i] == 0)
    order = []
    while q:
        node = q.popleft()
        order.append(node)
        for nxt in graph[node]:
            indeg[nxt] -= 1
            if indeg[nxt] == 0:
                q.append(nxt)
    return order if len(order) == num_tasks else []

Complexity: O(V + E) time and space. Dependency ordering recurs across Uber's build and scheduling problems.

Worked Solution 5: Dynamic Programming

Problem: Given an array of non-negative integers, find the maximum sum of a non-adjacent subsequence.

Approach: Rolling DP; at each index, take the better of skipping it or taking it plus the best two steps back.

def max_non_adjacent(nums):
    incl = 0
    excl = 0
    for x in nums:
        incl, excl = excl + x, max(incl, excl)
    return max(incl, excl)

Complexity: O(n) time, O(1) space. The two-variable rolling form is the clean answer when asked to minimise memory.

Design-Round Primer

Most Uber loops include design. For freshers, expect low-level design or a simple high-level discussion; for stronger candidates, a real-time-systems flavour (a ride-matching service, a notification system, a rate limiter). The approach:

1. Clarify requirements, functional and non-functional, with latency and scale in mind.
2. Identify core components and data flow.
3. Reason about real-time constraints, queues, and consistency.
4. Discuss trade-offs and failure handling.
5. Communicate with a clean diagram.

Given Uber's domain, showing awareness of latency, geospatial indexing, and high-throughput matching strengthens a design discussion.

How to Prepare for Uber Coding Rounds

• Prioritise graphs (shortest path, BFS/DFS, topological sort), heaps, and intervals, which are notably common at Uber.
• Add arrays, strings, hashing, and DP for breadth.
• Practise narrating your approach and stating complexity.
• Prepare design basics with a real-time-systems angle for relevant roles.

See Uber interview questions 2026 for the wider loop.

Eligibility and Key Dates (Reference)

Uber hires freshers and new grads through campus channels, referrals, and rolling careers-portal openings. The reference criteria below are compiled from candidate reports for 2023 to 2025 cycles and vary by role; the binding eligibility is whatever the specific job notification on the Uber careers portal states.

Eligibility figures are candidate-reported references (2023 to 2025), not official cutoffs. Uber opens roles in rolling windows; watch its careers portal and verified channels for live openings and dates. The job notification is binding.

More Worked Solutions

Worked Solution 6: Word Ladder (BFS)

Find the shortest transformation sequence from a start word to an end word changing one letter at a time. Model words as graph nodes and run BFS for the shortest path.

from collections import deque

def ladder_length(begin, end, word_list):
    words = set(word_list)
    if end not in words:
        return 0
    q = deque([(begin, 1)])
    while q:
        word, steps = q.popleft()
        if word == end:
            return steps
        for i in range(len(word)):
            for c in 'abcdefghijklmnopqrstuvwxyz':
                nxt = word[:i] + c + word[i + 1:]
                if nxt in words:
                    words.remove(nxt)
                    q.append((nxt, steps + 1))
    return 0

Time O(words times length times 26). A graph-as-implicit-nodes problem, exactly Uber's flavour.

Worked Solution 7: LRU Cache (Design)

Implement O(1) get and put with a hash map plus a doubly linked list ordered by recency. Discuss the node structure, moving accessed nodes to the front, and evicting the tail. Uber pairs DSA with this kind of design-coding.

Worked Solution 8: Task Scheduler (Greedy)

Given tasks and a cooldown, find the minimum time to run them all. Use the most frequent task to compute idle slots, a greedy interval-style problem relevant to scheduling systems.

from collections import Counter

def least_interval(tasks, n):
    counts = Counter(tasks)
    max_count = max(counts.values())
    max_count_tasks = sum(1 for v in counts.values() if v == max_count)
    return max(len(tasks), (max_count - 1) * (n + 1) + max_count_tasks)

Time O(t). Scheduling and cooldown problems map to Uber's real-time domain.

Why Uber Leans on Graphs, Heaps, and Intervals

Uber's coding rounds have a recognisable flavour, and understanding why helps you prioritise your preparation honestly. Uber's core systems are built around routing, matching, scheduling, and real-time decisions: connecting riders to drivers, computing routes and ETAs, balancing supply and demand, and processing events as they happen. These problems map almost directly onto graph algorithms, priority queues, and interval reasoning, which is why those topics appear more often in Uber's interviews than in a typical product company's.

Graphs are the clearest example. Shortest-path algorithms like Dijkstra correspond to routing and ETA computation, breadth-first search corresponds to spreading or reachability problems, and topological sort corresponds to ordering dependent tasks. Building genuine fluency here, being able to implement BFS, DFS, Dijkstra, and Kahn's algorithm cold and explain their complexity, is the single highest-leverage preparation for Uber. Heaps and priority queues come next, because top-k, merge-k, and scheduling-with-priority problems mirror how Uber ranks and dispatches in real time. Intervals round out the set, since availability, scheduling, and overlap problems map to driver and trip windows.

This does not mean you can ignore arrays, strings, hashing, and dynamic programming; they still appear and form the foundation. But when you allocate your study time, weighting it toward graphs, heaps, and intervals matches where Uber concentrates its questions. A candidate who can confidently solve a graph or scheduling problem at optimal complexity, narrating the approach and reasoning about the real-time analogue, is well aligned with what Uber is actually screening for. Pair that with clear communication and edge-case rigour, and you are prepared for Uber's medium-to-hard bar.

Why Candidates Lose Marks in the Uber Coding Round

Candidate reports point to recurring reasons strong candidates underperform:

• Stopping at brute force. Uber's medium-to-hard bar expects optimal solutions with correct complexity.
• Weak graph fundamentals. Given Uber's emphasis on graphs, shaky BFS, DFS, or shortest-path skills hurt.
• Coding in silence. Failing to narrate your approach and trade-offs loses signal.
• Skipping design prep. Most loops include a design round, often with a real-time-systems angle.
• Ignoring edge cases. Empty input, single element, and boundary values are common failure points.

Preparation Timeline (6 to 8 Weeks)

• Weeks 1 to 2: Foundations. Arrays, strings, hashing, and the graph basics (BFS, DFS).
• Weeks 3 to 4: Graphs and heaps. Shortest path, topological sort, top-k, merge-k, and interval problems, which are notably common at Uber.
• Weeks 5 to 6: DP and design. Subsequence and partition DP, plus design basics with a real-time-systems angle (rate limiter, ride matching).
• Weeks 7 to 8: Mocks. Timed mock coding interviews narrating out loud, plus a couple of design mocks.

Related Resources

• Uber interview questions 2026, commonly asked questions across rounds
• Uber placement papers 2026, solved past-drive papers
• System design interview questions freshers 2026, design fundamentals
• System design interview questions 2026, deeper design prep
• 7-day coding round crash plan 2026, last-week prep
• Off campus placement guide 2026, the master off-campus guide

FAQs: Uber Coding Round Questions 2026

Q: What topics does Uber focus on in coding rounds?

Graphs (shortest path, BFS/DFS, topological sort), heaps, and intervals are notably common, alongside arrays, strings, hashing, and dynamic programming, per candidate reports. Prioritise graphs and heaps.

Q: How hard are Uber coding questions?

Candidate reports place them at medium to hard, with clean code and clear reasoning expected. Uber's bar rewards optimal solutions with correct complexity analysis, not just passing brute force.

Q: Does Uber ask system design?

For most roles, yes. Freshers usually get low-level design or a simple high-level discussion; stronger candidates may get real-time-systems problems like ride-matching or rate limiting. Prepare design basics with a latency and scale angle.

Q: Why does Uber lean toward graph problems?

Uber's core systems involve routing, matching, and real-time decisions, which map naturally to graph algorithms like shortest path and topological sort. That domain alignment is reflected in its interview emphasis.

Q: What language should I use in the Uber coding round?

Use the language you are most fluent in, commonly Java, C++, Go, or Python. The interviewer cares about correctness, complexity, and clarity, not which language you choose.

Q: How important is communication in Uber coding rounds?

Important. Candidate reports emphasise narrating your approach, stating complexity, and reasoning about trade-offs. Silent coding loses signal even when the final solution is correct.

Q: Which graph algorithms should I master for Uber?

BFS and DFS for traversal and reachability, Dijkstra for weighted shortest paths with non-negative costs, and topological sort (Kahn's algorithm) for dependency ordering. These map to Uber's routing, ETA, and scheduling problems, so be able to implement them cold and explain their complexity.

Q: Does Uber include a design round for freshers?

Most loops include some design. Freshers usually get low-level design or a simple high-level discussion; stronger candidates may get a real-time-systems problem like ride matching or a rate limiter. Prepare design basics with a latency and scale angle.

Q: How should I prepare for Uber's medium-to-hard bar?

Drill the high-frequency patterns to optimal complexity rather than stopping at brute force, weight your time toward graphs, heaps, and intervals, and practise narrating and stating complexity. Timed mock interviews that include hints are the closest simulation of Uber's actual rounds.