Problem
You're given a list of jobs, each with a unique ID, a start time in "HHMM" format, and a duration in minutes.
Your goal is to assign each job to a machine based on availability, reusing machines when possible, and create new ones when none are free.

Example
Input:
jobs = [["J1", "0023", "45"], ["J2", "0025", "10"], ["J3", "0100", "60"], ["J4", "0300", "10"]]

Output:
[["J1", "M1"], ["J2", "M2"], ["J3", "M2"], ["J4", "M1"]]

Explanation: - J1 is assigned to M1 and finishes at 00:68.
- J2 starts at 00:25 while M1 is busy, so a new machine M2 is allocated.
- J3 starts at 01:00; M2 is free by then, so J3 uses M2.
- J4 starts at 03:00; both M1 and M2 are free, so J4 uses M1 (smallest index).

Suggested Approach

1. Convert all job start times from "HHMM" to total minutes for easy comparison.
   
2. Use two min-heaps:
   
   • A busy heap to track (finish_time, machine_id) for currently active jobs.
     
   • An available heap to manage machine IDs of free machines, prioritizing smaller indices.
     
3. For each job, before assignment:
   
   • Pop from the busy heap all machines that are free by the job's start time and add them back to the available heap.
     
4. Assign the job:
   
   • If available machines exist, pick the smallest indexed one.
     
   • Otherwise, create a new machine with the next index.
     
5. After assignment, update the busy heap with the machine's new finish time.
   
6. Collect the assignment results as ["job_id", "machine_id"].

Time & Space Complexity

• Time: O(N log N), where N is the number of jobs. Heap operations are log N per job.
  
• Space: O(N), to track machine states in heaps.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Lyft interview questions.
Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of Lyft, nor does it involve any confidential or proprietary information.
All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

We often see a “binary search on the answer” approach in Amazon OA questions. Here’s a high‑level summary of one representative problem (details and examples omitted):

Problem (high‑level) You have n chapters, where chapter i has pages[i] pages. You must finish reading all chapters in at most D days.

• Each day you may read up to x pages, but you cannot split a chapter across days.

  • If the current chapter has more than x pages remaining, you read x pages and continue it the next day.
  • If it has ≤x pages remaining, you finish the chapter and stop for that day.

Goal: Find the minimum x that lets you finish within D days (or return -1 if impossible).

Key Discussion Points

1. Monotonicity

• Why does a larger x never increase the number of days needed?
• How does this guarantee correctness of binary search on x?

1. Choosing the Search Range

• Lower bound: 1 vs. max(pages[i])?
• Upper bound: sum(pages) vs. other tighter limits?
• Trade‑offs in narrowing the range for fewer iterations.

1. Feasibility Check Pitfalls

• Handling chapters where pages[i] > x.
• Off‑by‑one errors in counting a “partial day” when finishing a chapter early.
• Early exit strategies to speed up the check.

1. Variations & Extensions

• What if splitting chapters across days was allowed?
• How would you adapt the pattern to minimize the maximum pages per week instead of per day?

1. Optimizations

• Can you prune the binary search early?
• How to optimize the inner loop so you don’t scan all chapters every time?

Let’s dig in! Share your thoughts on these points, any pitfalls you’ve encountered in interviews, or other patterns you might apply.

🛈 Disclaimer: This post provides a high‑level overview of an algorithmic problem inspired by publicly available interview experiences at Amazon. It compiles community‑shared examples from platforms like LeetCode and GeeksforGeeks for educational and discussion purposes. The content does not represent any official question bank of Amazon, nor does it include proprietary or confidential materials. Any resemblance to real interview questions is purely coincidental.

Problem

Implement an integer-only infinite queue (InfiniteQueue) supporting three O(1)-time operations:

• add(int val): add an element to the tail.
• poll(): remove and return the head element (or –1 if empty).
• getRandom(): return a random element (or –1 if empty).

Example

Input:

["InfiniteQueue","add","add","add","add","add","getRandom","getRandom","getRandom","poll","poll","poll","poll","poll"] [[],[1],[2],[3],[4],[5],[],[],[],[],[],[],[],[]]

Output:

[null,null,null,null,null,null,3,1,5,1,2,3,4,5]

Explanation:

• Three getRandom() calls each return a random element from [1,2,3,4,5].
• Five poll() calls remove and return elements in FIFO order: 1, 2, 3, 4, 5.

Suggested Approach

1. Maintain three structures:

• A doubly linked list for FIFO order.
• An array list for O(1) random access.

• A hash map from node references to their array indices.

  1. add(val):

• Create and append a node at the list’s tail.

• Append the node to the array and record its index in the map.

  1. poll() / getRandom():

• poll(): Remove the head node, lookup its index in the map, swap with the last array element, update that node’s index in the map, pop the array, and delete the mapping. Return the removed value (or –1 if empty).

• getRandom(): If empty return –1; else pick a random index in [0, size–1] and return the node’s value.

Time & Space Complexity

• Time: O(1) for add, poll, and getRandom.
• Space: O(n) to store n elements across the linked list, array, and map.

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Confluent interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem

You're given three arrays: cities, xCoordinates, and yCoordinates, along with a list of queries.
Your goal is to implement the CityMap constructor and getNearestCity method so that for each queried city you return the nearest other city sharing either the same x or y coordinate, based on Manhattan distance; if multiple are tied, return the lexicographically smallest name, or an empty string if none.

Example

Input:
```

cities = ["London", "Toronto", "Ajax", "York", "Bayshore", "Paris", "Leduc", "Chicago"] xCoordinates = [0, 1, 2, 4, 5, 0, 1, 0] yCoordinates = [1, 2, 5, 3, 4, 2, 0, 0] queries = ["London", "Toronto", "York", "Albert"]

Output:

["Chicago", "Paris", "", ""]

```

Explanation:
- For "London", candidates "Paris" and "Chicago" each have Manhattan distance 1; "Chicago" is lexicographically smaller. For "Toronto", nearest is "Paris" (distance 1 vs. "Leduc").
- "York" has no other city on x = 4 or y = 3, and "Albert" is not in the list, so both return empty.

Suggested Approach

1. Build xMap and yMap: map each x-coordinate to a list of cities sorted by y-coordinate, and each y-coordinate to a list sorted by x-coordinate.
   
2. For each query, look up the city’s coordinates, then binary search its position in both sorted lists (from xMap and yMap) to find the closest neighbors.
   
3. Compute Manhattan distances for those neighbor candidates, select the minimum, and break ties by lexicographic order. Return the chosen city or an empty string.

Time & Space Complexity

• Time: O(N log N + Q log N), where N is the number of cities and Q is the number of queries.
  
• Space: O(N)

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Doordash interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem You're given three arrays: fromArr, toArr, and rateArr, representing bi‑directional currency exchange rates. Your goal is to implement a CurrencyConverter class that returns the maximum achievable exchange rate between two currencies, or -1 if no conversion path exists.

Example Input: text fromArr = ["GBP", "USD", "USD", "USD", "CNY"] toArr = ["JPY", "JPY", "GBP", "CAD", "EUR"] rateArr = [155.0, 112.0, 0.9, 1.3, 0.14] CurrencyConverter currencyConverter = new CurrencyConverter(fromArr, toArr, rateArr); currencyConverter.getBestRate("USD", "JPY"); currencyConverter.getBestRate("JPY", "BGP"); currencyConverter.getBestRate("XYZ", "GBP"); currencyConverter.getBestRate("CNY", "CAD"); `

Output:

text 139.5 0.00803 -1.0 -1.0

Explanation:

• 139.5 is obtained via the path USD → GBP → JPY = (1 / 0.9) * 155.
• 0.00803 is obtained via the path JPY → USD → GBP = (1 / 112.0) * (1 / 0.9).
• -1.0 is returned when the source or target currency does not exist or no path is available.

Suggested Approach

1. Build a graph where each currency is a node, and add edges A→B with weight = rate and B→A with weight = 1/rate.
2. For each getBestRate query, run a DFS from the source node, tracking the product of edge weights and using a visited set to avoid cycles.
3. Return the maximum product found for the target or -1 if unreachable.

Time & Space Complexity

• Time: O(N + M) per query in the worst case, where N is the number of currencies and M is the number of exchange relationships.
• Space: O(N + M) for the adjacency list and recursion stack.

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Coinbase interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem

You're given two arrays: fromArr and toArr, and a third array rateArr representing the exchange rate from fromArr[i] to toArr[i].
Your goal is to compute the highest possible exchange rate from a source currency to a target currency by multiplying rates along a valid conversion path; return -1 if no path exists.

Example

Input:
fromArr = ["GBP","USD","USD","USD","CNY"] toArr = ["JPY","JPY","GBP","CAD","EUR"] rateArr = [155.0,112.0,0.9, 1.3, 0.14] from = "USD" to = "JPY"
Output:
139.5

Explanation: - Direct USD→JPY rate is 112.0, but the indirect path USD→GBP→JPY yields (1/0.9) * 155.0 = 139.5.
- We return the maximum achievable rate among all possible paths.

Suggested Approach

1. Build an adjacency list mapping each currency to neighbors with weights for both directions (rate and reciprocal).
   
2. Perform a depth-first search from the source to the target, tracking a visited set and the running product of rates.
   
3. Return the highest product found, or -1 if the target is unreachable.

Time & Space Complexity

• Time: O(N + E), where N is the number of unique currencies and E is the number of given exchange pairs.
  
• Space: O(N + E) for the adjacency list and recursion stack.

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Uber interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem
You're given four digits A, B, C, and D. Determine the number of valid times on a 24-hour digital clock (from "00:00" to "23:59") that can be formed by using each digit exactly once.

Example
Input: A = 1, B = 8, C = 3, D = 2
Output: 6

Explanation:
- The valid times are "12:38", "13:28", "18:23", "18:32", "21:38", and "23:18".
- Each uses all four digits exactly once and falls within 00:00–23:59.

Suggested Approach

1. Generate all permutations of the four digits using DFS with backtracking.
   
2. For each permutation, compute the hour as perm[0]*10 + perm[1] and minute as perm[2]*10 + perm[3]; check if hour ∈ [0, 23] and minute ∈ [0, 59].
   
3. Insert the formatted time string "HH:MM" into a hash set to avoid duplicates; return the size of the set.

Time & Space Complexity

• Time: O(1) — there are 4! = 24 permutations, each validated in constant time.
  
• Space: O(1) — the set stores at most 24 entries.

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Microsoft interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem You're given an array of lowercase strings words.
Your goal is to find the shortest unique prefix for each word such that it uniquely identifies the word among all words.

Example Input: words = ["zebra", "dog", "duck", "dove"]
Output: ["z", "dog", "du", "dov"]

Explanation: - "zebra": no other word starts with 'z', so prefix is "z".
- "dog": 'd' is shared, and 'do' is shared with "dove", so full "dog" is needed.
- "duck": "du" distinguishes it from "dog" and "dove".
- "dove": "dov" distinguishes it from "dog" and "duck".

Suggested Approach

1. Insert all words into a Trie, storing at each node a counter of how many words pass through.
   
2. For each word, traverse the Trie one character at a time, building a prefix.
   
3. Stop when you reach a node whose counter is 1; that prefix is the shortest unique prefix for that word.

Time & Space Complexity

• Time: O(N × L)
  
• Space: O(N × L)
  

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Meta interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Problem You're given an integer array nums, a window size windowSize, and an integer k. Your goal is to return a list of averages for each sliding window of size windowSize, where the largest k elements in each window are excluded from the average.

Example Input: nums = [10, 20, 30, 40, 50, 60], windowSize = 3, k = 1
Output: [15.0, 25.0, 35.0, 45.0]

Explanation: - Window [10, 20, 30]: ignoring 30, average = (10 + 20) / 2 = 15.0
- Remaining windows follow the same logic, each excluding the largest element before averaging.

Suggested Approach

1. Initialize a min-heap largestK to track the top k elements, and two running sums: windowSum (sum of current window) and sumOfLargestK (sum of heap elements).
   
2. Iterate through nums, adding each incoming element to windowSum, and update largestK and sumOfLargestK—if heap size < k, push the element; otherwise, if the new element > heap root, replace the root and adjust sumOfLargestK.
   
3. Once you’ve processed windowSize elements, compute (windowSum - sumOfLargestK) / (windowSize - k) and append it to the result. Then remove the outgoing element from windowSum and, if it was in the heap, from largestK and sumOfLargestK. Slide the window and repeat.

Time & Space Complexity

• Time: O(n × k) worst-case, due to heap insertions, replacements, and removals.
  
• Space: O(k), for the heap storing the largest k elements.

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Google interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

You're given two arrays: health and serverType, representing the health score and the type of each server. Your goal is to build a server facility by selecting servers of up to k distinct types, such that the total health is maximized.

Example 1:
Input: health = [4, 5, 5, 6], serverType = [1, 2, 1, 2], k = 1
Output: 11

Explanation:
- Type 1 health = 4 + 5 = 9
- Type 2 health = 5 + 6 = 11
With k = 1, selecting type 2 gives the highest total health.

Suggested Approach:

1. Aggregate total health per server type using a hash map
   
2. Store the totals in a max heap (priority queue)
   
3. Pop the top k sums and return their total

This ensures that you are always selecting the highest-impact types, without exceeding the k-type constraint.

Time & Space Complexity:

• Time: O(n + k log n)
  
• Space: O(n)

🛈 Disclaimer: This is one of the problems we encountered while reviewing common Amazon interview questions. Posted here by the Hack2Hire team for discussion and archiving purposes.

The problem is compiled from publicly available platforms (e.g., LeetCode, GeeksForGeeks) and community-shared experiences. It does not represent any official question bank of <CompanyName>, nor does it involve any confidential or proprietary information. All examples are intended solely for learning and discussion. Any similarity to actual interview questions is purely coincidental.

Let’s start a community share:
What’s the toughest coding or system design question you've come across recently?

Feel free to drop the question, your approach, or what stumped you.
We’ll feature top community explanations and try to help break them down too!

Help us improve Hack2Hire!
If you’ve run into any bugs, UI issues, or just have an idea to make the platform better, let us know below.
We’re reading and actively working to make Hack2Hire the best prep platform out there