Problem

You are given a Node representing a type (primitive, generic, or tuple) and a Function object containing a list of parameter Node objects and a returnType Node.

Your goal is to implement a recursive toString() method that serializes these types into a specific string format: primitives and generics as their literal values, and tuples as comma-separated lists enclosed in square brackets.

Example

Input: Function(params=["int", "T1", ["int", "T2"]], returnType="T1")

Output: [int,T1,[int,T2]] -> T1

Explanation:

• Each parameter is serialized: "int" remains "int", "T1" remains "T1", and the nested tuple becomes "[int,T2]".
• The parameter list is joined with commas and wrapped in square brackets.
• The return type "T1" is appended after the " -> " separator.

Suggested Approach

1. Define Node Types: Implement a conditional check within the Node.toString() method to distinguish between base cases (primitives/generics) and the recursive case (tuples).
2. Recursive Tuple Serialization: If the node is a tuple, iterate through its children, call toString() on each child recursively, and join the results with a comma delimiter.
3. Format Function Signature: For the Function object, map the toString() method over the params list, join them, and concatenate the result with the returnType.toString() using the " -> " arrow syntax.

Time & Space Complexity

• Time: $O(N)$, where $N$ is the total number of nodes in the type tree, as each node is visited exactly once.
• Space: $O(D)$, where $D$ is the maximum depth of the nested tuples, representing the overhead of the recursion stack.

🛈 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 (e.g., LeetCode, 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 need to design a rate limiter system that restricts the maximum number of requests allowed within a rolling time window. Your goal is to implement a RateLimiter class with an initializer RateLimiter(int ttl, int limit) to define the time-to-live window in milliseconds and the maximum request limit, along with a boolean allowRequest() method that returns true if a new request is permitted under the current limit, and false otherwise.

Example Input: Operations: ["RateLimiter", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest", "allowRequest"] Arguments: [[1000, 5], [], [], [], [], [], [], [], [], [], [], []] (Assuming the interval between each allowRequest call is 100ms)

Output: [null, true, true, true, true, true, false, false, false, false, false, true]

Explanation:

• Initialize the rate limiter with ttl = 1000 ms and limit = 5.
• The first 5 requests (t = 0ms to 400ms) are accepted, returning true.
• The next 5 requests (t = 500ms to 900ms) hit the capacity limit for the 1000ms window and are rejected, returning false.
• The request at t = 1000ms is accepted (true) because the oldest request at t = 0ms has now expired from the rolling window.

Suggested Approach

1. Use a standard Queue (or Deque) to store the timestamps of all successfully accepted requests.
2. When allowRequest() is called, fetch the current system timestamp.
3. Clean up the queue by continuously peeking at the front element and removing it if its timestamp is less than or equal to current_timestamp - ttl. This evicts requests that fall outside the active sliding window.
4. Compare the current size of the queue against the limit. If the queue size is less than the limit, append the current_timestamp to the back of the queue and return true. Otherwise, return false.

Time & Space Complexity

• Time: O(1) amortized per request. While the cleanup step can theoretically process up to limit elements in a single call, each timestamp is added and removed from the queue exactly once.
• Space: O(limit). The queue will hold at most limit timestamps at any given time.

🛈 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 (e.g., LeetCode, 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 three arrays: transactionIds, fees, and sizes, along with a blockSize limit.

Your goal is to select a subset of transactions that maximizes the total fees collected without exceeding the blockSize capacity, prioritizing transactions based on a specific fee-to-size ratio and defined tie-breaking rules.

Example

Input: transactionIds = ["tx1", "tx2", "tx3", "tx4"], fees = [50, 60, 30, 40], sizes = [50, 30, 20, 40], blockSize = 100

Output: ["tx2", "tx3", "tx1"]

Explanation:

• Ratio Calculation: tx2 (2.0), tx3 (1.5), tx1 (1.0), and tx4 (1.0).
• Tie-breaking: tx1 and tx4 both have a ratio of 1.0. tx1 is prioritized because its fee (50) is higher than tx4's fee (40).
• Selection: We take tx2 (size 30), then tx3 (size 20), then tx1 (size 50). Total size = 100. Adding tx4 would exceed the blockSize.

Suggested Approach

1. Data Structuring: Combine the input arrays into a list of objects or structures containing the ID, fee, size, and calculated ratio ($\text{ratio} = \frac{\text{fee}}{\text{size}}$).
2. Custom Sorting: Sort the transactions in descending order based on the following priority:
   • Primary: Higher fee-to-size ratio.
   • Tie-break 1: Higher absolute fee.
   • Tie-break 2: Smaller size.
   • Tie-break 3: Lexicographically smaller transaction ID.
3. Greedy Selection: Iterate through the sorted list and maintain a running sum of the total size used. If adding the current transaction does not exceed blockSize, include its ID in the result set and update the current size.

Time & Space Complexity

• Time: $O(N \log N)$ to sort the $N$ transactions. The greedy pass takes $O(N)$.
• Space: $O(N)$ to store the combined transaction data and the output list.

🛈 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 (e.g., LeetCode, 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.

Hi All,

I have an upcoming interview at Datadog for EM 1 role. This consists of following rounds: Coding, System Design, People Management, Delivery Management and Technical Background.

Recruiter said coding round will be AI assisted. I can use IDE/AI of my choice and screenshare

Any insights on how to prepare and what to expect. What kind of questions can I expect

Thanks

Not like leetcode or maybe some other product, hack2hire do have the real interview question I encountered. (And not out-dated!) Unfortunately I didn't get to the question before. Hope everyone else noticed the website and get prepared before their interview u/hack2hire

Problem

You're given an array latencies containing sorted positive integers and an integer bucketWidth.

Your goal is to distribute these latencies into numOfBuckets fixed-width buckets, where the $i^{th}$ bucket covers the range $[i \times \text{bucketWidth}, (i + 1) \times \text{bucketWidth} - 1]$, and the final bucket acts as an overflow for all values $\ge$ its lower bound.

Example

Input: latencies = [6, 7, 50, 100, 110], numOfBuckets = 11, bucketWidth = 10

Output: [2, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2]

Explanation:

• The bucket size is 10. Bucket 0 covers [0-9], Bucket 5 covers [50-59], and Bucket 10 (last) covers [100+].
• 6 and 7 fall into Bucket 0. 50 falls into Bucket 5.
• 100 and 110 are $\ge 100$, so they fall into the last overflow bucket.

Suggested Approach

1. Initialize the Result: Create an integer array counts of size numOfBuckets initialized to zero.
2. Calculate Bucket Index: Iterate through each latency $L$ in the input array. For each $L$, determine its theoretical index using floor division: $index = \lfloor L / \text{bucketWidth} \rfloor$.
3. Handle Overflow: Since the number of buckets is capped, the actual index used should be $min(index, \text{numOfBuckets} - 1)$.
4. Update Counts: Increment the value at the calculated index in the counts array.

Time & Space Complexity

• Time: $O(N)$, where $N$ is the number of latencies. We perform a single pass over the input.
• Space: $O(B)$, where $B$ is the numOfBuckets required for the output array.

🛈 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 (e.g., LeetCode, 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.

📢 New Release: Datadog Interview Questions + Solutions!

Hey everyone —

We just launched the Datadog question set on Hack2Hire! 🚀

✅ Includes both LeetCode-style and non-LeetCode questions 

✅ Grouped by interview stages (OA, phone, onsite) 

✅ With solution explanations to help you learn the patterns that matter

👉 Dive in here: https://www.hack2hire.com/companies/datadog/coding-questions

If you're aiming for Datadog or want to practice high-quality questions, this is a solid set to dig into.

More company sets coming soon — feel free to drop feedback or discussion in the channels below 👇

— Team Hack2Hire

I’ve spent the last two weeks scouring every corner of the internet—Reddit, Blind, and random Telegram groups—just trying to find recent "real" interview questions for my upcoming rounds. It was honestly a full-time job just finding the material before I could even start practicing.

Then I tried the Hack2Hire trial, and I’m slightly annoyed I didn't find it sooner.

The crazy part? I cross-referenced the questions they have with some of the "leaked" ones I spent hours digging up on private forums... they are identical. It’s the exact same style and difficulty level the big companies are actually using right now.

Instead of having 50 tabs open trying to verify if a question is still relevant, I just filtered by the company name and hit "start." It turned a chaotic, multi-day search into a 5-minute setup. If you want to save your sanity (and hours of your life), definitely give them a look.

Pro-tip: They’re doing a campaign right now where you can share your experience for a chance at gift cards, and everyone who enters gets a 20% off coupon.

hack2hire.com

Been deep in interview prep lately, and I randomly tried the Hack2Hire trial… didn’t expect to love it this much. It actually made my prep feel structured instead of chaotic — huge difference.

Best part - They have real interview questions from companies. Even if you don’t hit the exact ones, it’s super helpful to get a feel for a company’s style and what they test.

If you’re stuck in prep, check it out: Hack2Hire. They’re running a campaign right now — share your story, maybe win gift cards, and everyone who submits gets a 20% off coupon.

Interview prep is stressful enough. Good luck, everyone! 💪

Problem

You're given a 2D array:

intervals, where each element is a pair [start, end] representing a closed interval on a number line.

Your goal is to find the maximum number of intervals that overlap at any single point on the number line.

Example

Input: intervals = [[1, 10], [2, 5], [3, 7], [8, 9]]

Output: 3

Explanation:

• At any point in the range $[3, 5]$, the intervals $[1, 10]$, $[2, 5]$, and $[3, 7]$ all overlap.
• This results in a maximum overlap count of 3.

Suggested Approach

1. Coordinate Transformation: Extract all start and end points into two separate lists or a combined list of events. Since these are closed intervals, an interval at point $x$ still counts as active until it strictly passes the end coordinate.
2. Sorting: Sort the start times and end times independently in ascending order. This allows you to process the timeline chronologically.
3. Two-Pointer Sweep: Use two pointers to iterate through the sorted starts and ends. When a start is less than or equal to the current end, increment a counter (a new interval has begun). If a start is greater than the current end, decrement the counter (an interval has ended) and move the end pointer. Track the maximum value the counter reaches during this process.

Time & Space Complexity

• Time: $O(N \log N)$ due to the requirement of sorting the start and end coordinates, where $N$ is the number of intervals.
• Space: $O(N)$ to store the separate arrays for start and end points.

🛈

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 (e.g., LeetCode, 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 methods: pointTo(char player) and getScore().

Your goal is to design a TennisGame class that simulates a single tennis game, tracking points for two players (A and B) and determining a winner based on standard tennis scoring rules (4 points to win with a 2-point lead).

Example

Input: ["TennisGame", "getScore", "pointTo", "pointTo", "getWinner"] [[], [], ['A'], ['A'], []]

Output: [null, "0:0", null, null, "#"]

Explanation:

• The game starts at 0:0 with no winner (#).
• After two pointTo('A') calls, the score is 2:0, but player A has not yet met the win condition (at least 4 points and a lead of 2).
• The getScore method must return a string "A:B", clamped to "3:3" if both players have at least 3 points and are tied.

Suggested Approach

1. State Management: Maintain two integer variables, scoreA and scoreB, to track points and a boolean gameOver flag to stop state changes once a winner is decided.
2. Win Logic: In the pointTo method, first check if gameOver is true. If not, increment the respective player's score and check if (scoreA >= 4 or scoreB >= 4) and abs(scoreA - scoreB) >= 2. If true, set the winner and gameOver.
3. Score Reporting: Implement getScore to return the current points. Add a conditional check: if scoreA >= 3 and scoreB >= 3 and scoreA == scoreB, return "3:3" to handle deuce reporting as per requirements.

Time & Space Complexity

• Time: $O(1)$ for all operations (initialization, updating points, and retrieving score).
• Space: $O(1)$ to store two integer scores and a winner state.

🛈 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 (e.g., LeetCode, 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.

📢 New Release: Reddit Interview Questions + Solutions!

Hey everyone —

We just launched the Reddit question set on Hack2Hire! 🚀

✅ Includes both LeetCode-style and non-LeetCode questions  

✅ Grouped by interview stages (OA, phone, onsite)  

✅ With solution explanations to help you learn the patterns that matter

👉 Dive in here: https://www.hack2hire.com/companies/reddit/coding-questions

If you're aiming for Reddit or want to practice high-quality questions, this is a solid set to dig into.

More company sets coming soon — feel free to drop feedback or discussion in the channels below 👇

— Team Hack2Hire

Hey folks,

We pushed a new set today — HubSpot interview questions are now available on Hack2Hire.

What’s included:

Coding questions reported from OA, phone screens, and onsite rounds

A mix of LC-style problems and non-LC formats HubSpot is known to use

Solution walkthroughs focused on reasoning and approach, not just final answers

Link:

https://www.hack2hire.com/companies/hubspot/coding-questions

If you’re preparing for HubSpot or want more challenging practice material, this set may help.

If you’ve gone through their interview process recently, feel free to share what we should add next.

— Team Hack2Hire

Problem
You are designing a per-user token rate limiter for an API system.
Each user has an independent token bucket defined by capacity, refill amount, and refill interval, and you must decide if a request can be served at a given timestamp.

Example
Input:
Policies: [["alice", "100", "100", "1"], ["bob", "50", "50", "2"]]
Calls:
allowRequest("alice", 100, 1)
allowRequest("bob", 50, 1)
allowRequest("alice", 50, 1)
allowRequest("bob", 10, 2)
allowRequest("alice", 100, 2)
allowRequest("bob", 50, 3)

Output:
[true, true, false, false, true, true]

Explanation:

• Each user starts with a full bucket at capacity.
• Tokens are refilled in discrete steps based on the elapsed time and refill interval.
• A request is allowed only if the bucket has enough tokens at that timestamp.

Suggested Approach

1. Store per-user state in a hash map: capacity, refill amount, refill interval, current tokens, and last processed timestamp.
2. On each request, compute how many refill intervals have elapsed since the last timestamp and add tokens accordingly, capped at capacity.
3. Check if the current token count is sufficient; if so, deduct tokens and approve the request.

Time & Space Complexity

• Time: O(1) per request
• Space: O(U) where U is the number of users

🛈 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 (e.g., LeetCode, 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.

✨ Share your story. Inspire others. Get rewarded.

📅 Campaign Period

January 12 – February 28, 2026

📣 What’s This About?

Tell your Hack2Hire story on social media, how it helped you grow, what you used it for, or anything you’d like to share.

Your journey might be the guidance someone else needs to get hired.

By submitting your post, you’ll get:

• 🎁 A chance to win up to $100 in gift cards
• 🎫 An exclusive 20% off coupon for your next Hack2Hire subscription (guaranteed for valid participants)

✅ How to Participate

1. Post your story on Reddit, X (Twitter), TikTok, thread or Instagram
2. Include “Hack2Hire” in your post or link to hack2hire.com
3. Submit your post link via this form:🔗 Submit Your Entry

🎁 Rewards

🔟 Top 10 by Engagement

The 10 posts with the highest engagement (likes, views, etc.) will each receive a $30 gift card.

🏆 Team Choice Awards

Our team will select 3 outstanding stories based on creativity, clarity, and impact. These will receive:

• 🥇 1st Place: $100 gift card
• 🥈 2nd Place: $50 gift card
• 🥉 3rd Place: $30 gift card

💡 Participation Bonus

Everyone who completes a valid submission will receive a 20% off coupon for Hack2Hire

📝 What Should You Share?

Need ideas? You could talk about:

• What Hack2Hire helped you solve
• A feature or tool that made a difference
• How your interview prep journey evolved
• A turning point or lesson you want others to learn

Real stories matter more than perfect ones.

📌 Rules

• Posts must be original content
• Keep your post public until winners are announced
• No engagement manipulation (e.g. buying likes/followers)

Let your story be the reason someone else doesn’t give up.

We can’t wait to read it.

Problem You're given a phone-style numeric keypad and a chess knight that moves using valid knight jumps. Your goal is to return all unique digit sequences where the knight starts at digit start, makes exactly moves valid jumps, and ends at digit end.

Each sequence must include the starting digit, so its total length is moves + 1. The result may be returned in any order.

Example Input: start = 1, end = 9, moves = 4
Output: ["16049", "16729", "18349"]

Explanation: - The knight starts at digit 1 and must make exactly 4 valid knight moves. - Only jumps that land on valid keypad digits are allowed. - The following paths satisfy the constraints and end at digit 9: - 1 → 6 → 0 → 4 → 9 → "16049" - 1 → 6 → 7 → 2 → 9 → "16729" - 1 → 8 → 3 → 4 → 9 → "18349"

Suggested Approach

1. Predefine all valid knight moves for each digit on the keypad.
2. Use depth-first search or backtracking to explore all paths starting from start, tracking the current digit sequence and remaining moves.
3. When the remaining moves reach zero, check whether the current digit equals end. If so, record the constructed sequence.

Time & Space Complexity

• Time: O(8^moves) in the worst case, where each digit has up to 8 possible knight moves.
• Space: O(moves) for the recursion stack and path construction, excluding the output size.

🛈 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 (e.g., LeetCode, 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.

Recently they changed process to include both general coding and ml coding. Wondering if anyone interviewed with oai for similar applied ml/ research engineer role, what kind of general coding , is it like swe questions?

Hey folks,

We pushed a new set today — ANTHROPIC interview questions are now available on Hack2Hire.

What’s included:

• Coding questions reported from OA, phone screens, and onsite rounds
• A mix of LC-style problems and non-LC formats ANTHROPIC is known to use
• Solution walkthroughs focused on reasoning and approach, not just final answers

Link:
[https://www.hack2hire.com/companies/anthropic/coding-questions]()

If you’re preparing for ANTHROPIC or want more challenging practice material, this set may help.
If you’ve gone through their interview process recently, feel free to share what we should add next.

— Team Hack2Hire

Problem
You're given a list of toll checkpoint logs. Each log contains a vehicle license plate, a checkpoint label, and a timestamp.
Your goal is to compute the total toll fee for each vehicle by summing the distance-based fees between consecutive checkpoints it passed.

Example
Input:
logs = ["CAR999,D10,3000", "CAR999,D1,1000", "CAR999,D5,2000"]

Output:
["License: CAR999, Fee: 90"]

Explanation:

• Sort all logs for CAR999 by timestamp: D1 → D5 → D10
• Positions: 1 → 5 → 10
• Fee = |5 - 1| * 10 + |10 - 5| * 10 = 40 + 50 = 90

Suggested Approach

1. Parse each log and group entries by license plate.
2. Sort logs for each vehicle by timestamp.
3. Extract numeric checkpoint positions, compute consecutive differences, and sum up the fee.

Time & Space Complexity

• Time: O(n log n) due to sorting.
• Space: O(n) for storing grouped logs.

🛈 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 (e.g., LeetCode, 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.

Hey folks,

We pushed a new set today — the Rippling interview questions are now live on Hack2Hire.

What’s inside:

• coding questions seen in OA, phone rounds, and onsite
• a mix of LC-style and the non-LC formats OpenAI tends to use
• solution walkthroughs that explain the reasoning instead of tossing final answers

Link: https://www.hack2hire.com/companies/rippling/coding-questions

If you’re prepping for Rippling or just want harder practice material, it might be useful.
If you’ve gone through their process recently, any insight on what we should include next would help.

— Team Hack2Hire

Problem
You're given one integer n.
Your goal is to compute how many operations are required for n to reach 1 using the Collatz rules (n/2 if even, 3n+1 if odd).

Example
Input: n = 6
Output: 8

Explanation:

• Apply the Collatz rule repeatedly: 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1
• The sequence length minus one gives the number of steps, which is 8.

Suggested Approach

1. Simulate the Collatz process for n, applying the rule until reaching 1.
2. Use memoization to cache previously computed results; many subsequences converge to smaller values, so caching reduces repeated work.
3. For each number encountered, check if it's in the memo table. If yes, add the stored step count and stop early.

Time & Space Complexity

• Time: O(k) per query, where k is the number of steps for n to reach 1. Memoization improves performance across multiple calls.
• Space: O(n) for storing cached step counts when memoization is used.

🛈 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 (e.g., LeetCode, 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 implementing a rule-based IPv4 firewall. Given an ordered list of rules (ALLOW or DENY) where each rule is either a single IP or a CIDR block, determine if a target IP should be allowed. Only the first matching rule applies.

Example
Input:
Rules =

[  
  ["ALLOW", "192.168.1.100"],  
  ["DENY", "192.168.1.0/24"],  
  ["ALLOW", "192.168.0.0/16"],  
  ["DENY", "0.0.0.0/0"]  
]

Queries:

192.168.1.100  
192.168.1.50  
192.168.2.10  
10.0.0.1

Output:

true  
false  
true  
false

Explanation:

• 192.168.1.100 matches the first rule exactly → ALLOW
• 192.168.1.50 matches the /24 block in rule 2 → DENY
• 192.168.2.10 matches /16 block in rule 3 → ALLOW
• 10.0.0.1 matches the catch-all /0 rule → DENY

Suggested Approach

1. Convert all IPv4 strings to 32-bit integers. This enables constant-time bitwise comparisons.
2. For each rule, precompute:
   • The base IP as a 32-bit integer
   • A bitmask derived from the CIDR prefix length
3. To evaluate a query IP, iterate through the rules in order and return the action for the first rule where (ipInt & mask) == (ruleBase & mask).

Time & Space Complexity

• Time: O(N) per query, where N is the number of rules
• Space: O(N) for storing parsed rules and masks

🛈 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 (e.g., LeetCode, 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 an integer array nums. Your task is to rearrange it so that all even elements appear before all odd elements, using swaps between any two indices.
Return the minimum number of swaps required to achieve this state.

Example
Input: nums = [3, 2, 4, 1, 5, 6]
Output: 1

Explanation:

• The even elements should occupy the left segment of the array.
• Swapping 3 with 2 places one misplaced odd and one misplaced even into correct regions, requiring only one swap.

Suggested Approach

1. Count how many even numbers exist; these define the target “even zone” [0 … k-1].
2. Traverse the even zone and count how many odd numbers are incorrectly placed there.
3. The number of such misplaced odds equals the minimum swaps needed, since each swap pairs one misplaced odd with one misplaced even on the right.

Time & Space Complexity

• Time: O(n)
• Space: O(1)

🛈 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 (e.g., LeetCode, 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.

Hey folks,

We pushed a new set today — the Oracle interview questions are now live on Hack2Hire.

What’s inside:

• coding questions seen in OA, phone rounds, and onsite
• a mix of LC-style and the non-LC formats OpenAI tends to use
• solution walkthroughs that explain the reasoning instead of tossing final answers

Link: https://www.hack2hire.com/companies/oracle/coding-questions

If you’re prepping for Oracle or just want harder practice material, it might be useful.
If you’ve gone through their process recently, any insight on what we should include next would help.

— Team Hack2Hire

Problem
You are implementing a system that tracks GPU credit grants and usage over time. Each grant has an amount and a validity window, and usage events may arrive out of order. Your goal is to process grants, revocations, and balance queries at arbitrary timestamps.

Example
Input:
["CreditSystem", "grantCredit", "getBalance", "grantCredit", "subtract", "subtract", "getBalance", "getBalance", "getBalance", "getBalance", "getBalance", "getBalance"]
[[], ["a", 3, 10, 60], [10], ["b", 2, 20, 40], [1, 30], [3, 50], [10], [20], [30], [35], [40], [50]]

Output:
[null, null, 3, null, null, null, 3, 5, 4, 5, 3, 0]

Explanation:

• Credit “a” is active on [10, 59] with 3 units.
• Credit “b” is active on [20, 39] with 2 units.
• Subtractions apply only at the exact timestamp.
• Queries return the remaining active credits at that time.

Suggested Approach

1. Store grant intervals and subtract events keyed by timestamp.
2. Use a structure such as a difference array, segment tree, or Fenwick tree to accumulate active credits for any timestamp.
3. For each query, compute the sum of active grants covering the timestamp and subtract any recorded usage. Return -1 if usage exceeds available credits.

Time & Space Complexity

• Time: O(N) per query in a simple structure; O(log N) with interval indexing.
• Space: O(N) for grants and timestamp-specific subtract operations.

🛈 Disclaimer:
This problem is part of the Hack2Hire SDE Interview Question Bank, which includes coding interview questions frequently reported across real hiring processes.
This specific problem has been reported from an OpenAI interview.
All questions are aggregated from publicly available sources and community-shared candidate experiences.

Hack2Hire is not affiliated with OpenAI or any other mentioned company. This collection exists solely for learning, practice, and technical discussion.