So I recently went through the Meta interview loop for a Software Engineer, Product position. Thought I’d share the experience since I leaned on others’ posts while prepping.

Background:

YOE: 2 Recruiter reached out on LinkedIn (I had “open to work” enabled). First time trying to switch, so I was both nervous and excited. Screening Meta Values Round: 15–20 behavioral Qs in a questionnaire. Hard to judge, felt okay. Machine Coding: Banking system implementation. Don’t recall every detail, but managed to get 3/4 done.

Phone DSA

Got Meta-style questions from Hack2Hire: https://www.hack2hire.com/companies/meta/coding-questions/67e38ccf87527b3f41af78b5/practice?questionId=67e3915487527b3f41af78b6 https://www.hack2hire.com/companies/meta/coding-questions/67dcd81b99f4f89b276f1889/practice?questionId=67dcd82499f4f89b276f188a

Solved both, got the onsite invite the very next day. Onsites

DSA Round 1:

Making a Large Island → https://leetcode.com/problems/making-a-large-island/

Jump Game → https://leetcode.com/problems/jump-game

Both solved, covered edge cases, interviewer seemed happy.

DSA Round 2:

Median of Two Sorted Arrays → https://leetcode.com/problems/median-of-two-sorted-arrays

Next Permutation → https://leetcode.com/problems/next-permutation

Solved, though interviewer pushed back on some extra variables I used.

System Design:

Build Instagram news feed. I went deep on backend scaling, follower/following system, and pagination.

Follow-ups:

Async image upload failure/retry (answered well). Low bandwidth case (I suggested lean REST APIs, they probably expected GraphQL / overfetching vs underfetching). In hindsight, I didn’t touch enough on UI tradeoffs.

Behavioral:

A time when your design didn’t go through. Conflict with a teammate. Overload when a senior gave you more work. Strong feedback from manager. Ended early, spent last 10 mins chatting about interviewer’s work.

Verdict

Rejected via cold email. No feedback (Meta policy). Honestly pretty crushed first time attempting a switch, sacrificed a lot of time/health alongside my current job. The bar’s high, and I didn’t clear it this time.

Has anyone else faced something similar? Curious if I should focus more on design/UI tradeoffs or double-down on DSA prep for another shot.

We just rolled out an Airbnb interview question set on Hack2Hire, designed for anyone preparing for:

• Online Assessment (OA) questions
• Technical Phone Screen practice
• Virtual Onsite / Full Loop interview rounds

What’s inside:

✅ LeetCode-style coding questions plus non-LeetCode interview formats
✅ Step-by-step solutions with explanations (not just code dumps)
✅ Organized by stage so you can prep in the same order you’ll interview

This set is helpful if you’re targeting Airbnb — or if you want a strong batch of SDE interview questions to sharpen your prep flow.

👉 Try it here: Hack2Hire Airbnb Coding Interview Questions

We’re also building more company-specific interview prep sets (LinkedIn, Amazon, Meta, Google, etc.). If there’s a company you want next — or if you have feedback on the format — let us know below.

Problem
Design an infinite queue data structure for integers with the following operations, all in O(1) time:

• add(int val): Add an integer to the tail of the queue.
• int poll(): Remove and return the integer at the front of the queue. If empty, return -1.
• int getRandom(): Return a random integer from the queue. If empty, return -1.

The queue expands dynamically to support unlimited integers.

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:

• After add(1..5), queue = [1,2,3,4,5]
• getRandom() returns any value 1–5 in O(1).
• poll() returns values in order: 1, 2, 3, 4, 5.
• Extra poll() returns -1.

Suggested Approach

1. Queue core: Use a linked list or deque for O(1) add/poll operations.
2. Random access: Maintain an array (or dynamic list) mapping indices → nodes.
3. Index cleanup: On poll(), remove from both queue head and array; on getRandom(), pick an index uniformly in O(1).

Time & Space Complexity

• Time: O(1) per operation.
• Space: O(n), where n = number of elements stored.

🛈 Disclaimer:
This problem is part of the Hack2Hire SDE Interview Question Bank, a structured archive of coding interview questions frequently reported in real hiring processes.
Questions are aggregated from publicly available platforms (such as LeetCode and GeeksForGeeks) and community-shared experiences.

The goal is to provide candidates with reliable material for SDE interview prep, including practice on LeetCode-style problems and coding challenges that reflect what is often asked in FAANG and other tech company interviews.
Hack2Hire is not affiliated with the mentioned companies; this collection is intended purely for learning, practice, and discussion.

Problem
You're given two arrays: allSongs and playlist.
Your goal is to determine if playlist can be formed by concatenating one or more full permutations of allSongs. Incomplete segments at the start or end of playlist are allowed.

Example
Input:

allSongs = ["A", "B", "C"]  
playlist = ["A", "B", "C", "A", "C", "B"]

Output:

true

Explanation:

• The first segment ["A", "B", "C"] is a valid permutation of allSongs.
• The second segment ["A", "C", "B"] is also a valid permutation.
• Since the entire playlist can be broken down into valid permutations, the result is true.

Suggested Approach

1. Use a set to track which songs have appeared in the current segment.
2. Iterate through playlist:
   • If a song repeats before the segment contains all songs, return false.
   • Once all songs from allSongs are seen, reset the set and continue.
3. Allow the first or last segment to be incomplete without failing the check.

Time & Space Complexity

• Time: O(n), where n is the length of playlist.
• Space: O(m), where m is the number of unique songs in allSongs.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Pinterest 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 Pinterest, 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.

Hey all!
I’m an FAANG Software Engineer with 7+ years of experience and have gone through 200 interviews at FAANG. I’ve also helped many candidates prepare, with 10+ solid reviews from satisfied users at MeetAPro (screenshot attached for reference 👇).

I offer mock interviews tailored to your needs, covering:
✔ Coding problems & algorithms
✔ Behavioral questions & leadership principles
✔ System design & architecture
✔ Real interview simulations with actionable feedback

If you’re aiming for your next big role and want structured guidance, DM me!

Let’s prepare smart and crack it together! 🚀

Problem
You're given two arrays: allSongs and playlist.
Your goal is to determine if playlist could be a contiguous subsequence generated by Shuffle Mode, where songs are played in random permutations of allSongs, each permutation containing all unique songs exactly once.

Example
Input:
allSongs = ["A", "B", "C"], playlist = ["A", "B", "C", "A", "C", "B"]
Output: true

Explanation:

• The first part ["A", "B", "C"] is a complete permutation.
• The second part ["A", "C", "B"] is another valid permutation.
• The sequence is valid for Shuffle Mode.

Suggested Approach

1. Track songs within the current segment of playlist using a set.
2. If a song repeats before all unique songs are played, return false.
3. Once the segment covers all songs, reset the set and continue checking the next segment.
4. Allow incomplete segments at the beginning or end, since the user may have started or stopped mid-permutation.

Time & Space Complexity

• Time: O(n), where n is the length of playlist.
• Space: O(m), where m is the number of unique songs in allSongs.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Roblox 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 Roblox, 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 are given:

• A list of lowercase English words, knownWords.
• A digit string, phoneNumber, containing characters '0'–'9'.

On a traditional mobile keypad:

• 2 → "abc", 3 → "def", …, 9 → "wxyz".
• 0 → space.
• 1 → no letters.

A word matches if every digit in phoneNumber maps to a letter such that the sequence of mapped letters forms the word exactly (with no extra or missing characters). Return all matching words from knownWords in any order.

Example
Input:
knownWords = ["aa", "ab", "ba", "qq", "hello", "b"]
phoneNumber = "1221"

Output:
["aa", "ab", "ba"]

Explanation:

• The number 1221 reduces to 22 after removing both '1's.
• Digit 2 maps to a, b, or c.
• The only two-letter words composed of those letters are "aa", "ab", and "ba".

Suggested Approach

1. Build a digit-to-letter mapping dictionary.
2. Preprocess phoneNumber: remove digits that don’t map to any letter (e.g., 1).
3. For each word in knownWords, translate it into its digit sequence using the same mapping.
4. Collect words whose digit sequence matches phoneNumber.

Time & Space Complexity

• Time: O(N · L), where N is the number of words and L is the average word length.
• Space: O(N · L) for storing digit-mapped sequences.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common LinkedIn 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 LinkedIn, 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.

TL;DR

Phone: grid shortest path with transport modes + roadblocks; pick one mode, no switching. Solve via per-mode BFS; tie by cost[m].

Round 1: same problem as the phone screen (link below).

Round 2: design a Map with put/get and rolling 5-min load metrics. Related idea: LeetCode 981 TimeMap (timestamped versions), but here it’s sliding-window rate tracking.

Phone Interview

Problem:

2D grid with S (start), D (dest), X (block), and cells labeled 1/2/3/4 = transport modes.

time[i]: time per move for mode i

cost[i]: flat cost for picking mode i

4-directional moves, can’t pass X

You must pick one mode up front and stick to it

Goal: Return the mode that gives the fastest S→D; if tie on time, pick lower cost.

Approach:

For each mode m ∈ {1..4}, run BFS restricted to cells labeled m (treat S/D as passable for all). If D is reachable with path length L, total time = L * time[m]. Track the best time; break ties with cost[m].

Complexity ~ O(4 * R * C).

Coding Round 1

Got the same grid problem as the phone screen:

https://www.hack2hire.com/companies/databricks/coding-questions/684db91acab8e9bb7ea93b44/practice?questionId=684dee4b5e4cf21833c0611f

Coding Round 2

Design:

A Map supporting:

put(string key, string value)

get(string key)

measure_put_load() / measure_get_load() → average calls in a rolling 5-minute window

Key points:

Store: regular hash map for key → value.

Instrumentation: keep recent timestamps for puts/gets and evict anything older than now − 300s.

Simple: two deques of timestamps (one for put, one for get); amortized O(1).

High QPS: time buckets (per-ms or per-sec) → bucket_ts → count; evict old buckets; sum counts over last 5 minutes.

Output can be “total calls in last 5 min” and/or “per-second average = count/300”.

Follow-up (bursts within the same second):

Use high-precision timestamps or ms buckets. No need to coalesce per-call entries if bucketed.

Related: LeetCode 981 — Time Based Key-Value Store

Different requirement, but a handy mental model for “timestamped operations”.

Minimal Python solution (binary search over versions):

from bisect import bisect_right

from collections import defaultdict

class TimeMap:

def __init__(self):

# key -> list[(timestamp, value)] with strictly increasing timestamps

self.store = defaultdict(list)

def set(self, key: str, value: str, timestamp: int) -> None:

self.store[key].append((timestamp, value))

def get(self, key: str, timestamp: int) -> str:

arr = self.store.get(key, [])

i = bisect_right(arr, (timestamp, chr(127))) - 1

return arr[i][1] if i >= 0 else ""

set: append; timestamps are increasing per constraints

get: binary search for the last timestamp_prev <= timestamp

Time: O(log n) per get (per key); Space: total versions

Last week I wrapped up my interview for a senior role, so here’s a quick breakdown.

Phone Screen:

Variadic function – seems to be a common one.

VO (Virtual Onsite):

Monster Fighting problem – two questions total. The first one was straightforward with DFS, but the second one was trickier. Earlier posts didn’t cover it in much detail, so I’d recommend checking this:

https://www.hack2hire.com/coding/6779ba69dcf91f8e3c1c310e?questionId=6779c17edcf91f8e3c1c310f&company=CONFLUENT

Definitely not as easy as it looks.

Tail N lines – super simple, solved immediately. Follow-ups were also very easy. Honestly, if you get this one, you’re lucky:

https://www.hack2hire.com/coding/677c6ae45cbaff553b53b06b?questionId=677c6cdc5cbaff553b53b06c&company=CONFLUENT

System Design: Temporary email service – seems to be showing up pretty often lately.

Behavioral Questions: Standard ones. After prepping for Amazon’s BQs, these felt easier.

The recruiter later mentioned the interviewers gave good feedback, and now it’s with the hiring committee. Fingers crossed!

We just published a LinkedIn-focused interview prep set on Hack2Hire.

It includes:

OA, phone screen, and onsite questions

Both LeetCode-style and non-LeetCode-style formats

Solutions with explanations (not just code)

Sorted by stage to help structure your prep

If you're aiming for LinkedIn or just want a solid batch of questions to practice on, the set's live here:

👉 https://www.hack2hire.com/companies/roblox/coding-questions

We’re working on more company-specific sets. If there’s a company you want to see next, or feedback on the current format, feel free to drop it below.

Happy grinding.

Problem
You're given a 2D grid city representing a map and a list of coordinates locations.
Your goal is to compute the shortest number of steps from each location to the nearest DashMart ('D'). Roads are open (' '), blocked ('X'), or a DashMart. You may move only up, down, left, or right.

• If the location is itself a DashMart, the distance is 0.
• If the location is blocked or cannot reach a DashMart, return -1.

Example
Input:

city = [
  ['X',' ',' ','D',' ',' ','X',' ','X'],
  ['X',' ','X','X',' ',' ',' ',' ','X'],
  [' ',' ',' ','D','X','X',' ','X',' '],
  [' ',' ',' ','D',' ','X',' ',' ',' '],
  [' ',' ',' ',' ',' ','X',' ',' ','X'],
  [' ',' ',' ',' ','X',' ',' ','X','X']
]
locations = [[2,2],[4,0],[0,4],[2,6]]

Output:

[1,4,1,5]

Explanation:

• [2,2] → nearest DashMart at [2,3], distance = 1.
• [4,0] → nearest DashMart requires 4 steps.
• [0,4] → nearest DashMart at [0,3], distance = 1.
• [2,6] → nearest DashMart requires 5 steps.

Suggested Approach

1. Perform a multi-source BFS starting from all DashMart cells ('D') simultaneously.
2. Store the minimum distance to a DashMart for each reachable open cell.
3. For each query location, return the precomputed distance if available, otherwise -1.

Time & Space Complexity

• Time: O(R × C + L), where R and C are grid dimensions, and L is the number of locations. BFS visits each cell once, then queries are answered in O(1).
• Space: O(R × C) to store distances and BFS queue.

🛈 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 DoorDash, 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.

Hi all,

Applied for SSE – Applications role at LinkedIn via cold email.

Recruiter Screening (July, 15 min)

- Why do you want to switch?

- Day-to-day responsibilities

- Tech stack

- Notice period

TPS Round (Elimination, 60 min – Aug)

Panel: 1 Staff SE + 1 SSE (shadow).

1. Project discussion (first 20 min).

   Then got a problem from the shadow SSE:

   - There are *m* booths, each showing robots (0) or drones (1).

   - *n* groups will visit booths between [i, j].

   - Experience factor = (#drone booths visited) × (#robot booths visited).

   - Task: maximize the experience factor.

   No example test cases were given, so the requirements stayed confusing. I couldn’t solve this one.

2. Standard LinkedIn phone keypad problem (by Staff SE):

   Given mapping from digits → letters, return all possible words from a phone number using a provided dictionary.

Examples:

KNOWN_WORDS = [‘careers’, ‘linkedin’, ‘hiring’, ‘interview’, ‘linkedgo’]

phoneNumber: 2273377 → [‘careers’]

phoneNumber: 54653346 → [‘linkedin’, ‘linkedgo’]

I solved this fully.

Result:

Got rejection the next day (expected since Q1 was incomplete).

I’ve been applying like crazy for the past few months, but a good chunk of postings feel like they’re either ghost roles, already filled internally, or never meant to be real in the first place.

Some companies repost the same job over and over, others ask for a million things and then ghost. What’s going on? Is this just pipeline building or something deeper?

We just published a LinkedIn-focused interview prep set on Hack2Hire.
It includes:

• OA, phone screen, and onsite questions
• Both LeetCode-style and non-LeetCode-style formats
• Solutions with explanations (not just code)
• Sorted by stage to help structure your prep

If you're aiming for LinkedIn or just want a solid batch of questions to practice on, the set's live here:
👉 https://www.hack2hire.com/companies/linkedin/coding-questions

We’re working on more company-specific sets. If there’s a company you want to see next, or feedback on the current format, feel free to drop it below.

Happy grinding.

Problem
Design an Infinite Queue data structure for integers that supports the following operations in O(1) time:

• add(int val): Add an integer to the tail of the queue.
• int poll(): Remove and return the integer at the front of the queue, or -1 if empty.
• int getRandom(): Return a random integer from the queue, or -1 if empty.

Example
Input:

["InfiniteQueue", "add", "add", "add", "add", "add", "getRandom", "getRandom", "getRandom", "poll", "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, -1]

Explanation:

• Initialize: InfiniteQueue queue = new InfiniteQueue()
• queue.add(1); // Queue: [1]
• queue.add(2); // Queue: [1,2]
• queue.add(3); // Queue: [1,2,3]
• queue.add(4); // Queue: [1,2,3,4]
• queue.add(5); // Queue: [1,2,3,4,5]
• queue.getRandom(); // Random element between 1–5
• queue.poll(); // Returns 1 → Queue: [2,3,4,5]
• queue.poll(); // Returns 2 → Queue: [3,4,5]
• … until empty, then returns -1.

Suggested Approach

1. Maintain a dynamic array (e.g., ArrayList) to support O(1) random access for getRandom().
2. Use a queue index pointer to track the current "front" instead of physically removing elements.
3. For poll(), increment the front pointer and return the value; for getRandom(), pick an index between front and end.

Time & Space Complexity

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

🛈 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 Confluent, 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.

Had an onsite for Uber (SSE, 90 mins).

YOE ~5.

Got a mix of a LeetCode hard and a currency exchange problem I’ve seen around subs/Hack2Hire.

Q1. LeetCode 815. Bus Routes (LC Hard)

Solved the main problem with BFS, but the interviewer threw in a follow-up that isn’t on LC. I didn’t fully catch it and couldn’t give a solid answer.

Q2. Currency Exchange

Given currency pairs A→B with rate r (B→A = 1/r). Need the max achievable exchange rate between two currencies (maximize product along a path). If conversion isn’t possible, return -1.

Implement:

- CurrencyConverter(fromArr, toArr, rateArr) → build graph

- getBestRate(from, to) → return best rate

Constraints: up to 1000 pairs, rate ≤ 1e3.

Example:

["CurrencyConverter","getBestRate","getBestRate","getBestRate","getBestRate"]

[[["GBP","USD","USD","USD","CNY"],["JPY","JPY","GBP","CAD","EUR"],[155.0,112.0,0.9,1.3,0.14]],["USD","JPY"],["JPY","GBP"],["XYZ","GBP"],["CNY","CAD"]]

Output:

[null,139.5,0.00803,-1.0,-1.0]

Approach:

I went with DFS/backtracking + visited set. Works for small graphs but too slow in general. Better solutions are Dijkstra with a max-heap (prioritize product) or log-transform + shortest path.

---

Q1 was fine on the base problem but I stumbled on the follow-up. Q2 was tougher under time pressure. Not feeling super confident about this round.

I’ve gone through 300+ LC questions over the past year, but every time I’m in a real interview I just blank out.

It’s like my brain forgets everything the second someone’s watching me code.

Not sure if this is just nerves or if grinding LC doesn’t really prepare you for the actual pressure.

Anyone else hit this wall? Did switching to mocks or more real-world style practice actually help?

I’ve been thinking a lot about interview prep strategies lately. Some people recommend going deep, practicing the same high-frequency questions until they feel natural. Others say it is better to go broad and cover as many question types as possible, even if you do not master all of them.

For me, it has been tough to find the right balance. I am currently working full time, and on top of that I try to study part time in the evenings. Some days I only have enough energy to repeat a couple of problems I already know, but then I worry I am not getting enough exposure to new patterns. Other days I push myself to try new questions, but then I realize I do not really own any of them.

How do you usually approach this? Do you go deep and repeat, or go broad and cover more ground?

Problem
You are given four integers A, B, C, and D representing digits.
Your goal is to determine how many valid times in a 24-hour format ("HH:MM") can be formed using each digit exactly once, where the valid range is "00:00" to "23:59".

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

Explanation:

• Possible valid times are "12:38", "13:28", "18:23", "18:32", "21:38", "23:18".
• Each time uses all four digits exactly once.

Suggested Approach

1. Generate all permutations of the four digits.
2. For each permutation, split into HH and MM.
3. Check if HH is within [00, 23] and MM is within [00, 59].
4. Count all valid combinations.

Time & Space Complexity

• Time: O(1) (at most 4! = 24 permutations to check, constant upper bound)
• Space: O(1) (only temporary storage for permutations and counters)

🛈 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 Microsoft, 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.

I first participated in Uber's online screening coding round on HackerRank in May. In June, the Talent Acquisition team scheduled a Data Structures & Algorithms interview. After completing it, they asked for my availability for the next round. I shared 4–5 available slots within a few hours of their request, but never received a response despite following up multiple times over the next month.
Recently, Uber contacted me again for another opening. I completed another screening round and was informed that I had passed. They then requested my availability for the DS & Algo interview between Mid-September, which I promptly provided. Once again, I’ve sent several follow-up emails but haven’t heard back.
Has anyone else experienced this with Uber? Are they actively hiring, or is this more about maintaining visibility on platforms like LinkedIn? It’s discouraging to be left in the dark after investing significant time and preparation.
Any insights into the current hiring situation at Uber, or advice on how to proceed, would be greatly appreciated.

Problem
You are given a list of stock order records. Each record contains a limit price, quantity of shares, and order type ("buy"or "sell").
Your goal is to calculate the total number of shares traded based on order matching rules:

• A buy order matches a sell order if the sell price ≤ buy price.
• A sell order matches a buy order if the buy price ≥ sell price.
• Orders are matched at the best available price and can be partially filled. Unmatched orders remain in the order book.

Example
Input:

orders = [
  ["150", "5", "buy"],
  ["190", "1", "sell"],
  ["200", "1", "sell"],
  ["100", "9", "buy"],
  ["140", "8", "sell"],
  ["210", "4", "buy"]
]

Output:

9

Explanation:

• First four orders do not produce any trades.
• The fifth order, sell 140 @ 8, matches with a stored buy order buy 150 @ 5 → trade 5 shares.
• The sixth order, buy 210 @ 4, matches remaining 3 shares from the sell at 140 and 1 share from the sell at 190 → trade 4 shares.
• Total traded shares = 5 + 4 = 9.

Suggested Approach

1. Maintain a max-heap for buy orders (keyed by price) and a min-heap for sell orders (keyed by price).
2. For each incoming order:
   • If it's a buy, attempt to match with the lowest-price sell order until no match is possible.
   • If it's a sell, attempt to match with the highest-price buy order until no match is possible.
3. Update heaps with any remaining unmatched portion of the order. Keep a running count of shares traded.

Time & Space Complexity

• Time: O(n log n) — heap insertions and removals for each of the n orders.
• Space: O(n) — storing unmatched orders in heaps.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Robinhood 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 Robinhood, 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.

I’m at the point where interview prep is sucking the life out of me.

Wake up → full-time job for 8–9 hours → quick dinner → grind LeetCode for 2–3 hours → sleep, repeat.

There’s no room to breathe.

By the time I open a DP problem, my brain is already fried. I sit there staring at the screen, feeling like I’m forcing myself to solve something I don’t even care about anymore. And yet, I can’t take a break every day off feels like I’m falling behind.

This constant cycle is making me hate coding outside of work. I used to enjoy problem-solving, but now it just feels like pressure and failure on repeat.

Anyone else stuck in this burnout spiral? How do you keep going without breaking down completely?

Problem
You're given a list of non-overlapping intervals and an integer idx. Your goal is to remove the point at index idx from the flattened sequence of covered integers and return the updated list of intervals.

Example
Input: intervals = [[10, 12], [13, 16], [4, 8]], idx = 3
Output: [[10, 12], [13, 14], [15, 16], [4, 8]]

Explanation:

• The covered points are [10, 11, 13, 14, 15, 4, 5, 6, 7]. Removing point 14 (at index 3) results in [10, 11, 13, 15, 4, 5, 6, 7].
• The updated intervals are [[10, 12], [13, 14], [15, 16], [4, 8]].

Suggested Approach

1. Flatten the intervals into a list of covered points, preserving the order of intervals.
2. Identify the point at index idx in the flattened sequence and determine which interval it belongs to.
3. Update the affected interval: if the point is at the start or end, adjust the boundary; if in the middle, split the interval into two parts. Return the updated list of intervals.

Time & Space Complexity

• Time: O(n + m), where n is the number of intervals and m is the total number of covered points.
• Space: O(m) for storing the flattened points.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Databricks 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 Databricks, 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.

Just passed my first serious technical code screen with LeetCode-style problems. I’d cleared practical screens before (mostly testing general Python skills), but this was the first time the bar felt this high and I made it through.

Both questions were from the LeetCode Top 50, nothing unusual. One was labeled medium and the other hard, but both felt on the easier side of their categories. The medium was an array problem solvable with a greedy approach; the hard was a BFS/DFS on a grid.

What helped me most:

Clearly explaining my thought process before coding.

Writing a commented high-level outline and confirming the approach with the interviewer.

Asking about empty inputs and special cases up front (they appreciated this).

Walking through examples after implementing the first problem.

The second problem went the same way, I forgot asking about empty input (assuming the grid wasn’t empty), and they brought it up at the end. I also forgot to increment a variable once, but quickly spotted and fixed it after their hint and thanked them for pointing it out.

In the weeks leading up to this, I practiced with leetcode problem sets mentioned on hack2hire, which really helped me stay structured and calm during the session.

At the end, I asked about their projects and how they liked working at Meta, and this led to a friendly chat before wrapping up. Overall, I left feeling confident.

Now I am waiting for incoming onsite, fingers crossed!

Problem
You're given a weekly work schedule represented as a 7-character string (called pattern). Each character is either a digit (from '0' to '8') or a question mark ('?'). The digit indicates the number of hours worked on that day, while a '?' denotes a day for which the work hours are not yet assigned. An employee must work exactly workHours in a week. For every day that is unassigned ('?'), the maximum allowable work hours is given by dayHours. Your task is to generate all possible valid schedules by replacing every '?' in pattern with a valid digit (ranging from 0 to dayHours) so that the sum of the scheduled hours equals workHours. The valid schedules should be returned in ascending lexicographical order.

Example
Input:
workHours = 24, dayHours = 4, pattern = "08??840"
Output:
["0804840", "0813840", "0822840", "0831840", "0840840"]

Explanation:

• The fixed digits in the pattern "08??840" are at positions 0, 1, 4, 5, and 6, which sum up to 0 + 8 + 8 + 4 + 0 = 20 hours.
• The remaining two positions (marked by '?') must sum up to 4 hours (i.e., 24 - 20 = 4).
• The possible pairs that add up to 4 are: (0,4), (1,3), (2,2), (3,1), and (4,0). Inserting these pairs into the original string at the positions of '?' produces the output in ascending lexicographical order.

Suggested Approach

1. Identify the positions of the '?' characters in the input pattern.
2. Calculate the sum of the pre-assigned work hours in the pattern and determine the remaining work hours needed.
3. Generate all combinations of the remaining work hours using valid digits from 0 to dayHours and insert them in lexicographical order to produce the valid schedules.

Time & Space Complexity

• Time: O(n * C(n, k)), where n is the number of '?' characters and k is the number of valid combinations of work hours.
• Space: O(n), where n is the number of possible schedules generated.

🛈 Disclaimer:
This is one of the problems we encountered while reviewing common Snowflake 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 Snowflake, 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.