109 questions from 20 interviews · updated from reports 2017-2024
About
Uber is a technology company that runs ride-hailing, delivery, and freight platforms connecting users with drivers, couriers, restaurants, and shippers. In India, it hires for technical roles such as Software Engineering Intern, SDE-1, and Data Scientist.
The roles that come up most are Software Engineering Intern, SDE-1 and Data Scientist. This covers 20 candidate interviews reported from 2017 to 2024. Most sat it at entry level (10 of 18 that recorded a level), with 7 internship interviews alongside. Among the 15 that recorded either route, arrivals split between campus drives (10, 67%) and off-campus applications (5, 33%). Most questions fall under DSA and CS fundamentals.
Ans. Convert the binary number to an integer, then repeatedly divide by 6 and collect the remainders in reverse order. Use a string or stack to store base 6 digits as they are produced. Handle zero separately. The time complexity is O(n) for fixed-size integers, with O(log₆ value) extra space.
Ans. Use interval dynamic programming: pad the array with 1 at both ends, and let dp[left][right] be the maximum coins from bursting balloons strictly between left and right. For each interval, try every balloon as the last one burst, gaining nums[left] * nums[i] * nums[right]. The time complexity is O(n³) and space is O(n²).
Ans. Use Tarjan’s DFS algorithm on an undirected graph, tracking discovery time and the lowest reachable discovery time for each vertex. For every DFS tree edge u to v, if low[v] is greater than disc[u], that edge is a bridge. Store the graph as an adjacency list. Time complexity is O(V + E).
Ans. The bias-variance tradeoff is the balance between a model being too simple to capture the true pattern and too sensitive to noise in the training data. High bias causes underfitting, while high variance causes overfitting. Good models minimise overall prediction error by finding an appropriate level of complexity.
Ans. To delete a node in a doubly linked list, link its previous node to its next node and its next node back to its previous node. The key detail is handling boundaries: if it is the head, update the head; if it is the tail, update the tail. Deletion is O(1) when the node is already known.
Ans. Thrashing is a state where an operating system spends most of its time swapping pages between memory and disk instead of executing processes. It usually happens when there is not enough physical memory for the active working sets, causing constant page faults, very low CPU utilisation, and poor overall performance.
Ans. Ensemble learning combines multiple models to make a stronger overall prediction than a single model. The models may vote, average results, or be combined sequentially, as in bagging, boosting, and random forests. Its main advantages are better accuracy, improved robustness, reduced variance, and often less overfitting when the models are diverse.
Ans. The operating system handles a page fault by trapping from the process into the kernel, checking whether the memory access is valid, and loading the missing page into RAM if needed. If physical memory is full, it selects a victim page, may write it to disk, updates the page table, and restarts the instruction.
Ans. A thread is the smallest unit of execution within a process, sharing the process’s memory and resources while having its own stack and program counter. Multithreading runs multiple threads in one process to improve responsiveness, resource use, or parallelism. The key issue is safe shared state, using synchronisation to avoid races, deadlocks, and visibility bugs.
Ans. Use Tarjan’s DFS algorithm to find all strongly connected components in one pass. Maintain a stack, discovery index, low-link value, and an on-stack marker for each vertex. When a vertex’s low-link equals its discovery index, pop the stack until that vertex to form one component. Time is O(V + E).
Ans. Model it with classes such as Product, InventoryItem, Customer, Basket, Order, Payment and Store. Product holds catalogue data, InventoryItem tracks stock and price, Basket manages selected quantities, and Order confirms purchase and reduces stock. The key detail is separating catalogue, inventory and ordering so pricing, availability and checkout rules stay independent.
Ans. Decision trees split data using feature tests to make predictions, random forests average many decorrelated trees, and gradient boosting builds trees sequentially to fix earlier errors. The key difference is ensemble strategy: forests reduce variance by bagging and randomness, while boosting reduces bias by adding weak learners that optimise a loss function.
Ans. Implement a semaphore with an integer count, a mutex to protect it, and a waiting queue or condition variable. wait atomically decrements the count, blocking if it would become negative or zero depending on convention. signal atomically increments it and wakes one waiter. Each operation is O(1) excluding scheduling delay.
Ans. Use binary search on the answer: the minimum possible maximum pages assigned to any student. Search from the largest single book to the sum of all pages. For each mid value, greedily assign books in order and count required students. If students needed is within limit, try smaller. Time complexity is O(n log sum).
Ans. Choose the simplest model that matches the target, data size, latency needs and explainability requirement. For labelled tabular prediction, start with a strong baseline such as logistic regression or gradient boosted trees, validate with cross validation, compare against a business metric, then only move to deeper models if they clearly improve performance.
Ans. Threads are independent paths of execution within a process, while object-oriented programming organises code around objects that combine data and behaviour. Threads share memory, so synchronisation is needed to avoid race conditions. OOP focuses on encapsulation, inheritance, polymorphism and abstraction to make systems modular, reusable and easier to maintain.
Ans. Use dynamic programming where dp[i][j] is the maximum martians collectable up to cell i, j. Precompute row prefix sums for one direction and column prefix sums for the other, then set dp[i][j] to the better of coming from above or from the left. Use 2D arrays, with O(nm) time and space.
Ans. Use level order traversal with a queue storing each node and its positional index, as if the tree were a complete binary tree. For each level, the width is last index minus first index plus one. Normalise indices at each level to avoid overflow. Time complexity is O(n), space complexity is O(w).
Ans. Gradient descent is an optimisation method that adjusts model parameters to minimise a loss function. It repeatedly computes the gradient, which shows the direction of steepest increase, then updates parameters in the opposite direction by a step size called the learning rate. In machine learning, this trains models by reducing prediction error over data.
Ans. Denormalization is usually better for distributed systems when read performance and availability matter, because it avoids cross-node joins and reduces network calls. The key trade-off is consistency: duplicated data must be updated carefully, often with eventual consistency. Normalization is still useful when correctness, simple writes, and avoiding duplication matter more.
Ans. Define a clear hypothesis, choose a primary success metric, split users randomly into control and treatment, run the test long enough for adequate power, and compare results using statistical significance and confidence intervals. The most important detail is choosing metrics before the test, including guardrail metrics like latency, errors, revenue, or retention.
Ans. Design patterns are reusable solutions to common software design problems, used to make code easier to understand, maintain, extend and discuss. Singleton ensures a class has only one instance and provides global access to it. Factory creates objects without exposing creation logic, helping code depend on interfaces rather than concrete classes.
Ans. Use dynamic programming to solve subset sum and reconstruct one valid set of dishes. Keep a boolean table for reachable totals, plus a parent pointer storing which dish made each total. After filling it, backtrack from the final amount to print dishes. Time complexity is O(nA), where A is the amount.
Ans. Use binary search on the answer, the maximum ballots allowed in any box. For a candidate value x, each city needing a ballots needs ceil(a / x) boxes, so x is feasible if the total boxes needed is at most the available boxes. The smallest feasible x is the answer. Time complexity is O(n log maxA).
Ans. Use level order traversal and assign each node a position index as if the tree were complete. For each level, the width is last index minus first index plus one. Store pairs of node and index in a queue, normalising indices each level to avoid overflow. Time is O(n), space is O(n).
Ans. Optimise the dynamic programming by keeping only the states needed for the next transition, rather than the whole table. If each state depends only on the previous row or a fixed number of earlier states, use rolling arrays or variables. This keeps the same time complexity but reduces space from O(nm) to O(m) or O(1).
Ans. Large scale A/B tests face issues with biased assignment, interference between users, slow or noisy metrics, multiple comparisons, and unreliable logging. I would use a controlled experimentation platform with stable randomisation, precomputed power, guardrail metrics, sample ratio checks, and clear stopping rules. The most important detail is trustworthy instrumentation and assignment.
Ans. Use a sweep line over all busy intervals and return the gaps where the number of busy people is less than the total number of people. Add start and end events, sort them, maintain a busy count, and emit intervals within the working window when busy count is under n. Time complexity is O(m log m).
Ans. Merge everyone’s busy intervals, then find the gaps where no one is busy and choose a gap long enough for the meeting. Put all busy intervals into one list, sort by start time, merge overlaps, and scan between merged intervals. The time complexity is O(n log n), dominated by sorting.
Ans. Try every way to split the string into four parts, each of length 1 to 3, and count the splits where all parts are valid IP octets. A part is valid if it is between 0 and 255 and has no leading zero unless it is exactly “0”. There are at most 81 splits, so time is constant.
Ans. Use binary search on the possible range of N, checking the monotonic function at each midpoint to decide which half can still contain the answer. Maintain low and high bounds, update them until they meet, and return the smallest or exact N that satisfies the condition. Time complexity is O(log range).
Ans. A strong answer should describe a real design disagreement where both options were credible. Emphasise how you clarified requirements, compared trade-offs, involved the team, and chose based on evidence rather than preference. Interviewers listen for collaboration, technical judgement, calm facilitation, willingness to prototype or benchmark, and commitment to the final decision.
Ans. Use dynamic programming: if n is odd, the answer is 0; otherwise let m = n / 2 and compute dp[i] as the number of valid expressions using i pairs. Set dp[0] = 1, and use dp[i] += dp[j] * dp[i - 1 - j]. Time complexity is O(m²), space is O(m).
Ans. Start from the ocean borders and search backwards: from the Pacific edges and Atlantic edges, move to neighbouring cells with height greater than or equal to the current cell. Use DFS or BFS with two visited matrices or sets. The answer is cells visited by both searches. Time is O(mn), space is O(mn).
Ans. Use a stack to decode nested patterns by storing the current string and repeat count whenever you see “[”. Build numbers from digits and append letters normally. On “]”, pop the previous string and count, then append the current string repeated count times. Time is O(n plus output size), space is O(depth plus output size).
Ans. Use an array of prefix sums of the weights, then pick a random number from 1 to the total weight and binary search for the first prefix sum at least that number. Each index owns a range of size equal to its weight, so its selection probability is weight divided by total weight. Build is O(n), pick is O(log n).
Ans. Use depth first search with backtracking from every cell that matches the first character. Recursively try adjacent cells, usually up, down, left and right, matching the next character and marking the current cell as visited to avoid reuse. Unmark on return. Time complexity is O(mn * 4^L), where L is the string length.
Ans. Use an event driven system that records each passenger arrival and departure as timestamped events, keyed by passenger ID and airport visit ID. Store arrivals in a durable database, match departures to the open visit, then compute departure time minus arrival time. The key detail is idempotent event handling to avoid double counting retries or duplicate scans.
Ans. Sort the boxes by width ascending, and for equal widths by height descending, then find the longest increasing subsequence of heights. This gives the maximum number of boxes that can be nested with both dimensions strictly increasing. Use a binary-search LIS array, giving O(n log n) time and O(n) space.
Ans. Run a reverse search from both oceans and return cells reached by both searches. Instead of flowing downhill from every cell, start at Pacific and Atlantic borders and move to neighbouring cells with height greater than or equal to the current one. Use DFS or BFS with two visited sets. Time is O(mn), space is O(mn).
Ans. Build a set of all node addresses or indices, then scan every left and right child reference to ensure it is either null or in that set. Count each child’s indegree, requiring no node to have indegree above one and exactly one root. Finally traverse from the root; visit all nodes once with no repeats. O(n).
Ans. The minimum replacements are N minus the largest number of distinct existing values that already fit inside any range of N consecutive integers. Sort the unique values, then use a sliding window where max minus min is at most N minus 1. Duplicates cannot both be kept. Time complexity is O(N log N).
Ans. Use a hash map from user id to record and an order statistic balanced tree keyed by score descending, then insertion sequence ascending for ties. addUser assigns a monotonic sequence and inserts score zero. updateScore removes and reinserts the user with the new score. getRank is tree rank in O(log n). getFirstK scans first K in O(K).
Ans. A priority queue returns the highest or lowest priority item first, usually implemented with a heap array. Heapify moves a new or changed item up to restore order, while deheapify removes the root, replaces it with the last item, then moves it down. Binary heaps are simple and O(log n); Fibonacci heaps have better amortised decrease-key; pairing heaps are simpler and often fast.
Ans. Use binary search on the rope length and return the largest length that can produce at least K pieces. For a candidate length x, count pieces as sum of A[i] / x using integer division. If count is at least K, try larger; otherwise try smaller. Time complexity is O(N log max(A)).
Ans. Build a prefix sum array of the weights, generate a random value from 0 up to the total weight, then return the first number whose prefix sum exceeds it. This maps each number to an interval proportional to its weight. Preprocessing is O(n), each pick is O(log n) with binary search.
Ans. Use BookingSystem to manage Room objects and Meeting objects, with each room holding a calendar of bookings ordered by start time. Adding a room inserts it into a map by room id. Scheduling checks the target room’s ordered bookings for overlap, then stores the meeting. Cancelling removes it by meeting id. Operations are typically O(log n) with balanced indexes.
Ans. Use a balanced BST when you need efficient insertion, updates, deletion and ordered access, giving O(log n) operations. Arrays give O(1) indexed updates but O(n) insertion in the middle. Linked lists insert in O(1) once positioned but search is O(n). Priority queues give O(log n) insert and update if paired with an index map.
Ans. The maximum K is the first value, checked from n down to 1, for which a left to right greedy flip simulation can make the string all zero. For each fixed K, track active flip parity with a difference array. If the current effective bit is 1, a flip starting there is forced. Time is O(n²), space O(n).
Ans. Use a sliding window and keep the longest window where length minus the most frequent character count is at most k. Store character frequencies in a map or array, track the maximum frequency seen, expand right, and shrink left when replacements needed exceed k. The answer is the largest valid window length, in O(n) time.
Ans. Sort crops by minimum capital, then greedily repeat up to k times: add every crop now affordable to a max heap by profit, choose the most profitable one, and add its profit to capital. If no affordable crop exists, stop. Sorting plus heap operations gives O(n log n plus k log n) time and O(n) space.
Ans. Use an abstract Device interface with common methods turnOn and turnOff, and let Fan and TV implement it with their own extra methods. A RemoteController holds a map from device name to Device, dispatching common commands polymorphically. Device-specific commands can use specialised interfaces. Lookup is constant time, command execution is constant time.
Ans. Use a Dish class with name, a set of ingredients, and price, and a RestaurantMenu class holding dishes in a list plus an ingredient-to-dishes map. Adding stores the dish and updates the map. Printing scans all dishes. Billing sums selected prices and applies GST. Ingredient filtering is O(1) lookup plus result size.
Ans. Sort the boxes by height ascending, and for equal heights by width descending, then find the length of the longest strictly increasing subsequence of widths. That length is the maximum number of nested boxes. Use a tails array with binary search for the LIS, giving O(n log n) time and O(n) space.
Ans. Use multi-source BFS starting with all taxi stands in the queue at distance zero, and expand only through road cells. When the passenger cell is first reached, it is guaranteed to be from the nearest stand. Store a parent coordinate for each visited cell, then backtrack from passenger to stand and reverse it. Time is O(rows times cols).
Ans. Design Excel as a grid UI backed by a sparse cell store, a formula parser, and a dependency graph for recalculation. Each cell stores value, formula, format, and dependencies. Formula changes update the graph, detect cycles, and recompute affected cells topologically. Persist workbooks as compressed structured files with sheets, styles, formulas, and metadata.
Ans. Split projects into non-negative and negative reward groups. Do all non-negative projects first, sorted by minimum required rating ascending, updating the rating. For negative projects, sort by a + b descending and check both rating >= a and rating + b >= 0. This greedy order is optimal, with O(n log n) time.
Ans. Use interval dynamic programming, choosing the last balloon burst in each subarray. Pad the array with 1 at both ends, and let dp[left][right] store the best score for bursting only balloons between them. Try every last balloon as a split point. This uses a 2D table, O(n^3) time and O(n^2) space.
Ans. Pick a real project where you were stuck but stayed structured. Emphasise how you clarified the problem, checked assumptions, researched, tested options, and asked the right people for input before time was wasted. Interviewers listen for persistence, judgement, collaboration, transparency, and learning, not heroic solo problem solving.
Ans. Pick a real failure with manageable impact, not a character flaw or disaster. Explain the context briefly, own your part without blaming others, and focus on what changed afterwards. Interviewers listen for self-awareness, accountability, resilience, and evidence that you improved your judgement, communication, planning, or follow-through as a result.
No question matches those filters. Reset filters.
Showing 60 of 109 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover DSA (57%) and CS fundamentals (23%).
Candidate interviews show an average of 3.3 rounds per experience, with a typical sequence of Online test → Technical → System design → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 16%, medium 61%, hard 23%.
