DEV Community: interviewshow-cs

TikTok Intern OA Experience: Familiar Problems, Two Questions Worth Remembering

interviewshow-cs — Wed, 12 Aug 2026 14:09:51 +0000

TikTok Intern OA rounds are starting to roll out again in batches. After opening the assessment, the overall problem style felt fairly familiar, and I was able to move through it relatively quickly. A typical OA has four questions. Below are the two questions from this round that are worth documenting, especially if you are preparing for the TikTok Intern process.

Question 1: Sort Each k-Border and Write It Back Clockwise

Given an n × n integer matrix, define the 0-border as the outermost layer consisting of the first row, last row, first column, and last column.

After removing the 0-border, the outer layer of the remaining matrix becomes the 1-border. The same definition applies to 2-border, 3-border, and so on, up to floor((n - 1) / 2).

For every k-border, extract all elements in that layer, sort them, and then write them back to their original positions starting from the top-left corner and proceeding in clockwise order.

Approach

The simplest implementation is to process the matrix layer by layer.

For each layer, calculate top, bottom, left, and right. Then collect the elements in this order:

Top row: left → right
Right column: top + 1 → bottom
Bottom row: right - 1 → left
Left column: bottom - 1 → top + 1

This avoids counting the four corners more than once. After collecting the values, simply sort the array and write the sorted values back using the exact same traversal order.

The problem does not require an especially optimized solution, so an O(n³) implementation can still pass. The main thing to watch is indexing, especially when the innermost layer contains only one element.

Question 2: How Many Segments Remain After Removing Houses?

You are given several houses located at distinct integer positions on a number line. The initial positions are stored in houses. The queries array gives the order in which houses are removed.

After removing each house, return the number of remaining house segments. A segment consists of one or more houses occupying consecutive positions. A single isolated house also counts as one segment.

For example:

houses = [1, 2, 3, 6, 7, 9]
queries = [6, 3, 7, 2, 9, 1]

output = [3, 3, 2, 2, 1, 0]

Approach

A clean solution is to maintain the current number of segments while processing the queries from left to right.

First, calculate the initial number of segments from all houses. Then store the currently active house positions in a set or ordered data structure.

When removing a house at position x, only its immediate neighbors x - 1 and x + 1 matter:

Both neighbors exist: one segment is split into two, so the segment count increases by 1.
Only one neighbor exists: the house was at the end of a segment, so the count stays unchanged.
Neither neighbor exists: the house was an isolated segment, so the count decreases by 1.

After processing each query, append the current segment count to the answer array.

The key observation is that removing one position only affects its two adjacent positions, so there is no need to scan the entire array after every deletion. This gives an efficient implementation with roughly O(n + q) expected time when using a hash set.

Overall Takeaway

TikTok Intern OAs often have four questions with a relatively tight time limit, but the difficulty is usually manageable if you are familiar with common implementation patterns. These two problems are good examples: the first is mainly matrix simulation plus sorting, while the second is about maintaining connected segments under deletions.

If you are preparing for a TikTok Intern OA, it is worth reviewing matrix traversal, simulation, hash sets, sorting, and simple dynamic connectivity patterns before starting the assessment. When the question looks familiar, recognizing the underlying pattern quickly can save a lot of time.

Need More TikTok OA & Interview Preparation?

If you are currently preparing for TikTok, Meta, Google, Amazon, or other North American tech interviews, Interview Show provides interview preparation and assistance services covering OA preparation, coding practice, system design, mock interviews, and Virtual Onsite preparation.

You can visit Interview Show to learn more about the available services and get personalized preparation support for your upcoming technical interviews.

Roblox OA Experience: Mini-Games + Coding, Two Coding Problems Fully Solved

interviewshow-cs — Tue, 11 Aug 2026 13:12:28 +0000

The Roblox OA is quite different from a typical Big Tech coding assessment. Instead of focusing entirely on LeetCode-style problems, the assessment combines several timed mini-games and decision-making tasks before moving into the actual Coding Skills section.

The overall format felt somewhat similar to the modular, time-limited structure used by companies like Optiver. Each section has its own fixed time limit, and once you start a section, you cannot switch to another one. Managing your time and staying focused is therefore really important.

Roblox OA Format

My assessment was roughly divided into the following sections:

Robots: 25 minutes
Factories: 25 minutes
Decision-Making: 25 minutes
Outpost: Mars: 40 minutes
Coding Skills: 50 minutes / 2 problems

The first four sections are not traditional programming questions. They are more focused on following instructions, making decisions quickly, and adapting to the rules of each mini-game.

Once you enter a section, the timer is locked to that section, so you cannot pause it and come back later. Keeping track of your time is especially important.

Coding Skills: Two Problems

I got full credit on both coding problems. The two questions were quite different in style, but neither required an extremely complicated algorithm.

Problem 1: Reordering 4×4 Matrices with Missing Numbers

You are given a large matrix with dimensions 4 × (4 × n). It consists of n separate 4×4 matrices placed side by side.

Each 4×4 matrix has one missing number represented by ?.

The task is to:

Find the missing number in each 4×4 matrix.
Fill in the missing value.
Sort the 4×4 matrices by their missing values in ascending order.
If two matrices have the same missing value, preserve their original relative order.
Combine the sorted matrices back into the original large matrix format.

The key observation is that the sum of all numbers in a complete 4×4 matrix is:

1 + 2 + ... + 16 = 136

So for each small matrix, the missing value can be calculated as:

missing value = 136 − sum of the existing values

After filling in the missing values, the rest is essentially matrix slicing + stable sorting.

The main implementation challenge is correctly splitting the large matrix into individual 4×4 blocks and then putting the sorted blocks back together.

Problem 2: Stock Trading Robot and Maximum Profit

The second problem was more algorithmic.

You are given:

prices: the stock price for each day
algo: the robot's original action for each day, where 0 means buy and 1 means sell

The robot performs exactly one action per day. You are allowed to choose one consecutive interval of length k and change all actions in that interval to sell.

The goal is to maximize the total profit.

The easiest way to think about it is to first calculate the profit using the original strategy.

Then, for every day where the original action is buy, changing that action to sell increases the profit by:

2 × price

For days that are already sell actions, changing them has no additional effect.

Therefore, we can construct a gain array representing the additional profit obtained by changing each position to sell.

Now the problem becomes finding the maximum sum of a consecutive subarray of length k.

That can be solved efficiently with a sliding window:

Calculate the original trading profit.
Build the gain array.
Calculate the sum of the first window of length k.
Slide the window across the array while maintaining its sum.
Take the maximum gain.
Return base profit + maximum gain.

The overall complexity is O(n), which is enough for large inputs.

My Takeaways from the Roblox OA

The biggest difference between this assessment and a traditional coding OA is that coding is only one part of the entire evaluation.

For the non-coding sections, I would recommend following the instructions carefully and avoiding spending too much time getting stuck on one task. Since each section has its own fixed timer, losing several minutes in one section can be costly.

For the Coding Skills section, 50 minutes for two problems is tight but manageable. In my case, the first problem was mainly about matrix manipulation and stable sorting, while the second was based on calculating the original result and then using a sliding window to optimize the modified strategy.

If you're preparing for Roblox, it is worth practicing problems involving matrix slicing, stable sorting, simulation, sliding windows, and strategy optimization. These patterns can be more useful here than simply memorizing a large number of advanced algorithms.

Final Thoughts

Overall, I found the Roblox OA quite interesting because it tests more than just coding speed. The combination of mini-games, decision-making, and programming makes the assessment feel noticeably different from a standard Big Tech OA.

If you're preparing for Roblox or other Big Tech OA/VO interviews, you can also check out Interview Show for more interview experiences, OA questions, and preparation resources.

Why Bloomberg Interviews Make Strong LeetCode Candidates Fail

interviewshow-cs — Sun, 09 Aug 2026 06:06:16 +0000

I recently finished the full Bloomberg 26NG SDE interview process and wanted to share my experience while everything is still fresh.

Many candidates think Bloomberg is a "finance giant with good benefits and a relatively easier interview process" compared with companies like Google or Meta. But after going through the entire process, I realized the difficulty comes from somewhere many candidates don't prepare for:
your problem-solving process and communication matter as much as the final code.

Some candidates solve every problem correctly but still get rejected. Others may not reach the optimal solution but receive offers. Bloomberg is not only evaluating whether you can solve problems — they want to understand how you think, how clearly you communicate, and whether you can build reliable systems.

This mindset appears throughout the entire interview loop.

How Many Rounds Does Bloomberg SDE Interview Have?

Many people assume Bloomberg only has a phone screen and onsite interviews. In reality, the full process usually looks like:

Phone Screen → VO1 → VO2 → HR → EM Interview

The whole process usually takes around 2.5 months from application to final decision. The timeline is relatively efficient, and most rounds provide feedback within about a week.

One important detail: Bloomberg interviews usually require camera on and screen sharing throughout the process. If you are not used to this format, practice beforehand because it can affect your interview rhythm.

Phone Screen: Easy Coding, Difficult Behavioral Questions

The phone screen is around 45 minutes. The first 10 minutes focus on resume discussion, followed by coding questions.

The coding problems are usually Easy to Medium level, but many candidates underestimate the behavioral portion.

"Why Bloomberg?" Is Not a Question You Can Ignore

A common mistake is memorizing Bloomberg company information and repeating it during the interview. Interviewers are not looking for a company introduction.

They want to know whether you understand:

What Bloomberg Terminal provides
Why financial data infrastructure requires high reliability
Why low latency matters in financial systems
Why Bloomberg's engineering challenges match your background

Connecting Bloomberg's products with your own technical experience creates a much stronger answer.

Coding Questions

The questions I received were:

Validate Binary Search Tree
Longest Palindromic Substring

For BST validation, I used inorder traversal and maintained the previous node value.
For longest palindrome, I used center expansion.

The code itself was not difficult. However, the interviewer followed up with deeper questions:

How would you handle integer boundary cases in BST validation?
Is there an O(n) solution for longest palindrome?

These follow-ups are where Bloomberg evaluates your depth. Mentioning techniques like using infinity boundaries or Manacher's algorithm is enough — you usually don't need to implement them.

VO1 and VO2: Follow-ups Matter More Than the First Solution

Each virtual onsite round lasts around 60 minutes. Usually, you spend a few minutes discussing your resume, then move directly into coding.

The pace is fast. Two Medium problems plus follow-ups require you to finish each solution quickly while explaining your reasoning.

VO1 Experience

The first problem was a string matching problem. Given two equal-length strings, secret and guess, return:

* for exact matches
+ for characters that exist but appear in different positions
- for missing characters

The key detail is that each character can only be matched once. The correct approach is using Counter instead of Set:

First pass handles exact matches
Second pass handles misplaced matches
Decrease character counts after every match

The follow-up focused on duplicate characters, which is exactly why frequency counting matters.

The second problem was counting valid triangle triplets. The standard approach is sorting and using two pointers, achieving O(n²).

VO2 Experience

The first problem was flattening a multilevel linked list with next and child pointers.

I used a stack-based DFS approach:

Push next nodes into the stack
Connect child nodes directly
Continue traversal
Restore next pointers from the stack

The interviewer asked whether O(1) space was possible. The discussion was more important than the final answer — they wanted to see whether I understood the trade-offs.

The second question was an object-oriented design problem:
Design a subway system that supports check-in, check-out, and average travel time queries.

The design used:

HashMap for active passengers
HashMap for route statistics

Follow-ups focused on concurrency and distributed scaling. This is where Bloomberg shows its engineering-focused interview style.

HR Round: Not Just a Formality

Many candidates relax after technical rounds, assuming HR is guaranteed. Bloomberg HR still evaluates motivation and alignment.

You may be asked:

Why Bloomberg?
What Bloomberg products do you know?
How is Bloomberg different from other fintech companies?
What are your long-term career goals?

Weak answers can still hurt your chances.

EM Interview: The Most Challenging Round

The Engineering Manager round usually lasts 45-60 minutes. Depending on the team, it focuses on resume deep dive, system design, or both.

Resume Deep Dive

EM interviews go much deeper than simply asking what you built.

Expect questions like:

Why did you choose this architecture?
What alternatives did you consider?
What would you improve if rebuilding the project?
If traffic increased 10x, where would the bottleneck be?

System Design: Financial Systems Matter

One design question was:
Design a real-time stock price subscription system.

Users subscribe to stocks, and the system pushes price updates whenever prices change.

The architecture:

Exchange Data → Kafka → Price Processor → WebSocket Gateway → Users

Subscription data is stored in Redis for fast access, while persistent storage remains in a database.

Follow-ups included:

100K users subscribing to the same stock: Use batching and broadcast updates.
Service restart: Rebuild Redis cache from persistent database storage.
Latency requirements: Financial systems require low latency, and WebSocket is more suitable than HTTP polling.

The Real Reason Bloomberg Interviews Are Difficult

After completing the entire process, my biggest takeaway is:

Bloomberg is not looking for someone who can only solve algorithm problems. They want engineers who can build reliable systems in a high-pressure environment.

In financial systems, missing an edge case or making a poor design decision can create real impact.

Bloomberg evaluates:

Attention to edge cases
Understanding of trade-offs
Ability to communicate technical decisions
Engineering maturity

Tips for Bloomberg Interview Preparation

Coding

Focus on:

Trees
Two pointers
HashMap
Linked lists
Object-oriented design

Practice solving Medium problems within 15 minutes while explaining your thoughts clearly.

Behavioral Preparation

Prepare a strong "Why Bloomberg" answer. Understand Bloomberg Terminal, financial infrastructure, and connect them with your own experience.

System Design

The goal is not designing the most complicated system. The goal is explaining your decisions, handling follow-up questions, and showing structured thinking.

For more interview experiences, OA reviews, and SDE preparation resources, visit
InterviewShow.

Databricks 26NG Full Interview Experience Review (Phone Screen to Onsite)

interviewshow-cs — Fri, 07 Aug 2026 12:58:07 +0000

Just received the final feedback from Databricks. Overall, the process was fast-paced and well organized. The interviewers were friendly, discussions went deep, and the recruiter response time was among the fastest I have experienced at large tech companies. The biggest takeaway: Databricks places significantly more emphasis on distributed systems and concurrency compared with many traditional software companies.

Interview Process Overview

The full process was:

Technical Phone Screen
HR Scheduling for Onsite
One-day Virtual Onsite: 2 Coding Rounds + Behavioral + System Programming

The entire timeline was around three weeks. After each round, feedback usually came the same day or the following day.

Technical Phone Screen

Weighted Graph Shortest Path (BFS / Dijkstra)

The question focused on finding the optimal path in a weighted graph. After implementing the standard priority queue-based Dijkstra solution, the interviewer followed up:

"What if there are multiple transportation methods, such as walking, buses, and driving, where each option has different cost and time?"

I explained that the edge weight could be modeled as a multi-dimensional vector instead of a single value. The problem then becomes a multi-objective optimization problem where we search for Pareto optimal solutions. The interviewer accepted the approach and the round ended successfully.

Onsite Interview Rounds

Coding Round 1: Circular House Robber

This was a classic House Robber problem with an additional circular constraint. The solution was to split it into two linear cases:

Do not rob the first house
Do not rob the last house

Then return the maximum result from both scenarios. The discussion covered edge cases and complexity analysis. The follow-up question asked how the state transition would change if houses had additional dependencies.

Coding Round 2: Interval Removal + Streaming Scenario

The first part involved removing intervals and handling different overlapping cases. Then the interviewer extended the problem into a streaming scenario where deletion intervals continuously arrive.

After clarifying the requirements, I proposed maintaining the current interval collection and discussed different implementation trade-offs:

Simple list-based approach for smaller datasets
Segment tree or advanced interval structures for better scalability

This round lasted around 35 minutes and focused heavily on engineering judgment.

Behavioral Interview

The behavioral round focused on:

Deep dive into resume projects
Handling conflicts
Most impactful project experience

For conflict resolution, I shared an example where we used A/B testing data to make decisions instead of relying on opinions. For the most impactful project discussion, I mentioned that if rebuilding it, I would introduce monitoring and alerting earlier.

The interviewer appreciated the focus on engineering maturity and operational awareness.

System Programming Round (Databricks-Specific)

This was the most distinctive round and closely matched Databricks' engineering culture.

The problem involved designing a CacheFile class:

Retrieve files remotely
Return data based on offset and length
Support multiple clients

The discussion focused on:

Multiple clients requesting the same file simultaneously
Cache eviction strategy
Prefetching under network latency

The solutions discussed included:

Per-file locking for concurrency control
LRU cache eviction
Background prefetching
Priority queues for scheduling

The interviewer agreed with the design direction. The round ended before completing full implementation, but the overall approach was considered solid.

Preparation Advice

Coding questions are mostly around Medium difficulty. Focus on writing clean code and handling follow-up questions.
Prepare 3-4 strong behavioral stories with measurable impact, decision-making process, and lessons learned.
System Programming is where candidates can differentiate themselves. Practice thread-safe data structures, caching systems, and distributed system fundamentals.
Reading implementations from projects like Spark and Delta Lake can help understand Databricks' engineering mindset.

Final Thoughts

Overall, Databricks has a very engineering-focused interview process. The System Programming round especially reflects their focus on distributed systems, storage, concurrency, and large-scale data infrastructure.

If your background is not heavily focused on concurrency or distributed systems, spending two extra weeks specifically preparing these areas can make a significant difference.

Good luck with your Databricks interview preparation!

If you are preparing for Databricks or other infrastructure-focused software engineering roles, you can find more interview preparation resources, system programming materials, and real interview experiences at:

InterviewShow

Anthropic OA Latest Review: Inference Engine + Extra Trees Debug

interviewshow-cs — Thu, 06 Aug 2026 11:15:50 +0000

Just finished the latest Anthropic OA and wanted to share a detailed breakdown while the experience is still fresh.

At first glance, these two problems may look unfamiliar because they are not typical LeetCode-style questions. But both are very aligned with Anthropic’s interview style: instead of testing memorized algorithms, they focus on whether you can understand AI systems, debug machine learning code, and handle engineering details correctly.

Problem 1: Inference Engine (Request Scheduler)

The first problem is essentially building a simplified GPU request scheduler.

When a user request arrives, it first goes through the Prefill stage, where the model processes the input and builds the KV Cache. After that, it enters the Decode stage, generating one token at a time.

The GPU has a limited token processing capacity per timestep (batch capacity), and your job is to decide which requests should be scheduled onto the GPU at each step.

This is not asking you to implement a full LLM serving system like vLLM. The key is getting the scheduling logic correct and making sure the request state transitions are handled properly.

The Four Most Common Failure Points

1. Mixing Up Request States

Each request needs a clear lifecycle:

Waiting → Prefilling → Decoding → Finished

A request cannot enter Decode before Prefill is completed. Incorrect state transitions are one of the easiest ways to fail hidden tests.

2. Not Removing Finished Requests

Completed requests must be removed from active queues immediately. Keeping finished requests around can affect later scheduling decisions and cause unexpected failures.

3. Exceeding Batch Capacity

You cannot put unlimited requests into one timestep. If the current batch capacity is full, remaining requests must wait for the next scheduling round.

4. Overengineering the Solution

A common mistake is trying to simulate a real production LLM engine. The OA only evaluates scheduler correctness. A clean state machine with proper queue management is enough.

Implementation Approach

A simple and reliable approach:

Maintain explicit request states.
Use queues to manage waiting and active requests.
At each timestep, process available prefill/decode work.
Update states after execution.
Remove finished requests immediately.

The core idea is treating the scheduler as a state machine rather than trying to model every detail of an inference engine.

Problem 2: Debug Extremely Randomized Trees

The second problem gives you an incomplete or buggy implementation of Extremely Randomized Trees (Extra Trees) and asks you to fix the code until all tests pass.

This is not a from-scratch implementation problem. The challenge is reading unfamiliar ML code, understanding the intended behavior, and locating subtle bugs.

Three Common Bug Categories

1. Missing Edge Case Handling

Many failures come from unhandled edge cases:

Empty datasets
Only one sample remaining
Nodes that cannot be split further

Before splitting a node, always verify whether the current data can actually be partitioned.

2. NumPy Shape Issues

NumPy dimension bugs are extremely common in ML code.

For example:

(10,)
(10, 1)

These may look similar but behave differently in indexing, broadcasting, and matrix operations.

Be careful with operations like squeeze() and reshape(), and keep the data dimensions consistent throughout the implementation.

3. Random Split Creating Empty Children

Extra Trees randomly selects split features and thresholds. Some random splits can produce an empty left or right child.

If this case is not handled, recursive tree construction can fail.

Recommended Debugging Process

Run all provided tests and identify failing cases.
Start fixing from the smallest edge cases.
After every change, rerun tests.
Keep modifications minimal instead of rewriting the entire implementation.

Large-scale rewrites usually introduce more bugs. The goal is to understand the existing code and repair it efficiently.

What This OA Really Tests

These two problems represent Anthropic’s engineering-focused interview style.

The first problem checks whether you understand fundamental LLM inference concepts:

Prefill
Decode
KV Cache
Batching
Request scheduling

The second problem checks whether you can work with real machine learning code:

Debug existing implementations
Handle edge cases
Understand recursive algorithms
Work carefully with NumPy

This is not just about solving algorithm puzzles. It is about reading systems, understanding requirements, and writing reliable engineering code.

Preparation Advice

For students preparing for Anthropic, OpenAI, and other AI-focused companies, these areas are worth prioritizing:

Understand basic LLM inference concepts: Prefill, Decode, KV Cache, Continuous Batching.
Practice reading and debugging existing ML code.
Be comfortable with tree models and recursive implementations.
Pay close attention to NumPy shapes and boundary conditions.
Build the habit of writing explicit state transitions and defensive checks.

Need Help Preparing for AI Company Interviews?

For candidates targeting Anthropic, OpenAI, Google, and Meta, we are InterviewShow. Our team has experience preparing candidates for top AI and big tech interviews, with a focus on OA strategy, coding practice, and Virtual Onsite preparation.

From understanding AI company interview patterns to improving technical communication and system design skills, we help candidates build a structured preparation plan.

If you are preparing for AI company interviews, feel free to reach out and discuss your preparation strategy.

Snowflake OA Two Real Questions Solved 2026 Latest Solution Walkthrough

interviewshow-cs — Wed, 05 Aug 2026 13:12:32 +0000

I recently finished the Snowflake OA. Overall, it was more approachable than expected. With the right approach, the two questions were very manageable within the time limit. Snowflake's OA style is more focused on engineering implementation rather than pure algorithm tricks. The key is understanding the operation order and avoiding unnecessary re-computation.

Question 1: Minimum Height (Tree Optimization)

Given a rooted tree, you can perform at most max_operations operations. In each operation, you choose a non-root node and move the entire subtree rooted at that node directly under the root. The goal is to minimize the final tree height.

Core Idea: Greedy Strategy — Move the Deepest Nodes First

The height of a tree is determined by its maximum depth. Therefore, each operation should target the node that contributes the most to the current height.

The approach:

Run DFS/BFS to calculate the depth of every node.
Sort nodes by depth in descending order.
Process the deepest nodes first instead of recalculating the entire tree after every operation.
Maintain the set of nodes that currently determine the maximum height.

The key challenge is avoiding repeated traversal after every move.

Key Concepts

Tree traversal (DFS/BFS)
Greedy selection
Optimization to avoid repeated computation

Question 2: Horizontal Pod Autoscaler (Auto Scaling Simulation)

There are n services, each with an initial number of pods. A sequence of logs describes operations:

[1, service_id, x]: Update the pod count of a specific service to x.
[2, -1, x]: Increase all services whose current pod count is smaller than x to x.

Return the final pod count of every service after executing all operations.

Core Idea: Process Logs Backwards

A direct simulation will repeatedly scan all services during global scaling operations, which can easily exceed the time limit.

Instead, process operations from the end to the beginning:

Maintain a global minimum pod threshold caused by the latest scaling operation.
When encountering a global scaling operation, update this threshold.
When encountering a single-service update: if this service has not been processed before, this is its final effective update, so record it directly.
Services without a later individual update take: max(initial_value, global_threshold).

Overall complexity: O(n + m).

Overall Experience

This Snowflake OA mainly tests observation skills and implementation ability rather than advanced algorithm knowledge.

The two most important patterns are:

Greedy decisions: handle operations with the largest impact first.
Reverse simulation: reconstruct the final state by processing operations backwards.

For preparation, it is worth practicing greedy problems with limited operations and reverse-processing problems involving logs or state changes. These patterns appear frequently in data infrastructure companies.

Prepare for North America SWE OA & VO

Need help preparing for North American software engineering interviews? Interview Aid focuses on technical interview preparation, including OA practice, VO mock interviews, and one-on-one guidance.

We provide targeted preparation strategies for companies such as Snowflake, Databricks, and other data infrastructure companies.

You can visit Interview Aid for more interview resources and preparation support.

Good luck with your OA and interviews!

Google SDE Virtual Onsite Interview Experience | The Hiring Bar Is Higher Than You Think

interviewshow-cs — Tue, 04 Aug 2026 12:37:05 +0000

I recently completed the full Google Software Engineer Virtual Onsite interview process. Overall, the coding rounds focused much more on abstraction, communication, and handling changing requirements than simply solving LeetCode problems. Behavioral questions were also highly conversational rather than scripted.

The onsite consisted of four independent interview rounds, each evaluated separately. Preparing for each round individually is much more effective than treating the interview as one long session.

Round 1: Behavioral Interview (45 Minutes)

My interviewer was an Asian engineer who started with casual conversation about the weather, TV shows, and how long I had been in the U.S. The atmosphere was relaxed before moving into behavioral questions.

Main Questions

What interests you most about Google?
Why do you want to join Google?
What was your specific responsibility in your resume projects?
Which project was the most challenging and why?
How do you handle disagreements within a team?

Round 2: Behavioral + Coding

The interviewer was from India. The speaking pace was relatively fast, but the interview was well structured.

Behavioral Questions

Why Google?
Describe a time when you identified and mitigated a technical risk.

Coding Problem: Merge Intervals

The coding question was the classic Merge Intervals problem.

The expected solution was straightforward:

Sort intervals by starting time.
Greedily merge overlapping intervals.
Overall complexity: O(N log N).

Follow-up

How would you merge intervals that cross midnight, such as 23:00–02:00?

A clean approach is to split each cross-day interval into two normal intervals before performing the standard merge algorithm.

Round 3: Coding Only

This interviewer was from Korea and created the most relaxed atmosphere of the day. There was almost no behavioral discussion—we went straight into coding.

Coding Problem

Group binary tree nodes by the round in which they would be removed if leaves were deleted repeatedly.

The key observation is that each node's "removal round" equals its height from the nearest leaf.

Perform a post-order traversal.
Compute each node's height.
Group nodes by height.

Google frequently asks tree-related questions. More importantly, interviewers evaluate how clearly you explain your reasoning and communicate during implementation.

Round 4: Coding + Behavioral

Behavioral Questions

How do you ensure delivery of critical projects under limited resources?
How would you explain a complex technical concept to non-technical stakeholders?
Describe a time when technical innovation improved your team's efficiency.

Coding Problem: Email Address Normalization

Normalize email addresses by:

Removing dots (.) in the local name.
Ignoring everything after a plus sign (+).
Using a HashSet to count unique email addresses.

Follow-up

How would you process billions of email addresses?

Possible discussion points included:

Hash-based sharding for distributed processing.
Local deduplication within each partition.
Kafka for real-time streaming pipelines.
HyperLogLog for approximate distinct counting.
Bloom Filters for duplicate detection.

Overall Takeaways

Google's interview bar is definitely high. Solving the coding problem is only the starting point. Interviewers pay close attention to how you:

Abstract the problem.
Handle changing requirements.
Analyze edge cases.
Communicate your thought process.
Discuss scalability and system-level follow-ups.

If you're preparing for Google, Meta, Microsoft, TikTok, or other major tech company virtual onsite interviews, practicing communication and follow-up discussions is just as important as practicing algorithms.

Google, Meta, Microsoft, TikTok, and many other 2026 New Grad and Experienced Software Engineering interviews are currently ongoing.

At Interview Show, we specialize in North American software engineering interview preparation, including OA support, virtual onsite coaching, mock interviews, and real interview experience sharing. Our team has extensive experience with interviews at top tech companies and provides practical guidance based on recent interview trends.

Good luck with your interview preparation, and hope to see you land your dream offer!

TikTok OA Review: Finished 4 CodeSignal Problems in Minutes — The Pattern Is the Real Advantage

interviewshow-cs — Mon, 03 Aug 2026 12:02:41 +0000

Just finished the TikTok 26NG OA on CodeSignal. Four questions, and the whole thing was done in around ten minutes.

This is not about showing off speed. The reason it felt fast is that TikTok’s OA question bank has a very recognizable pattern. The first two problems are usually simulation-style easy points, the third focuses on data structures, and the fourth is often a scheduling simulation problem. The style is highly similar to the CodeSignal sets used by HRT, Uber, and Capital One.

If you have practiced similar problems before, the experience is almost like rewriting familiar solutions. I summarized the four problems and the core approaches below for anyone preparing.

Problem 1: Drone Delivery Walking Distance

Starting from position 0, deliver a package to the target location. There are charging stations along the route. Each round, the drone flies to the nearest station ahead and can travel at most 10 units. If the drone cannot reach the destination, you have to walk to retrieve the package and continue the process. Calculate the total walking distance.

The key idea is greedy simulation:

Sort all charging stations.
Find the next available station ahead.
Add only the walking distance to the answer.
Update the current position after the drone flight.
Continue until reaching the destination.

Remember that drone distance does not count toward the answer. Also handle the edge case where there are no charging stations — in that case, simply walk directly to the target.

Problem 2: Newspaper Text Alignment

Given paragraphs of words, an alignment mode (LEFT/RIGHT), and the maximum line width, format the text with a star border.

Use a two-pointer simulation:

Keep adding words while they fit in the current line.
When the next word exceeds the limit, start a new line.
After generating each line, add spaces according to the alignment rule.
Add the border characters at the end.

Most mistakes happen in formatting details:

The border does not count toward the line width.
The spaces between words must be calculated correctly.
Final line formatting rules need extra attention.

It is worth testing multiple custom cases locally before submitting.

Problem 3: Most Similar Mountain Heights

You are given mountain heights. Only mountains with an index distance of at least viewingGap can be compared. Find the pair with the smallest height difference.

The brute-force solution is too slow for large inputs. The optimized approach is:

Scan from left to right.
Maintain previous eligible mountain heights in an ordered data structure.
For the current height, check the closest previous values using predecessor and successor search.
Update the minimum difference.

A balanced tree or sorted set works well. Another option is coordinate compression with a Fenwick Tree when needed.

Problem 4: Phone Backup Battery Scheduling

A phone needs to run for t minutes. Batteries are used in order. After a battery is exhausted, it must recharge before it can be used again. If all batteries are charging at the same time, return -1. Otherwise, return the number of batteries used.

This is a simulation with state tracking:

Maintain the next available time for each battery.
At every step, find a battery that can currently be used.
Update its next available charging time.
Continue until the required time is completed.

The most important edge case is the deadlock scenario where every battery is unavailable at the same moment.

Suggested Time Allocation

Problem	Recommended Time
Drone Delivery	5-8 minutes
Text Alignment	8-12 minutes
Mountain Heights	10-15 minutes
Battery Scheduling	8-12 minutes

Leave some extra time to check edge cases before submitting.

FAQ

Is TikTok 26NG OA the same as the internship OA?

The platform and overall style are very similar. Both usually use CodeSignal, with mostly Easy-Medium difficulty and significant overlap in question patterns.

Do I need a Fenwick Tree for the third problem?

Not necessarily. An ordered set with binary search is enough in many cases. The important part is avoiding an O(n²) brute-force solution.

Which other companies use similar CodeSignal OA styles?

Companies like HRT, Uber, Visa, and Capital One often have very similar 70-90 minute CodeSignal four-question formats. Practicing this style can cover multiple companies at once.

Final Thoughts

TikTok’s OA pattern is relatively stable. Once you are comfortable with simulation, formatting problems, range queries, and scheduling problems, the test becomes much more predictable.

The interesting part is that this question style is not limited to TikTok. The same CodeSignal patterns appear across multiple large tech companies.

We are InterviewShow. We have organized 130+ real CodeSignal OA questions covering the 70-minute four-question format. These core patterns and frequently tested topics are fully covered. If you are preparing for a specific company, feel free to reach out for a targeted practice list.

Good luck with your interviews!

HRT OA 2026 Review: CodeSignal 70-Minute Assessment (All 4 Questions Explained)

interviewshow-cs — Sun, 02 Aug 2026 16:52:05 +0000

I just finished HRT's Online Assessment on July 27. The OA was hosted on CodeSignal and consisted of four coding problems to be completed in 70 minutes.

The biggest takeaway is that the question pattern is extremely consistent. The first two problems are relatively straightforward, the third focuses on matrix simulation, and the fourth requires an optimized data structure solution. If you've practiced CodeSignal OAs for companies like TikTok, Uber, Visa, or Capital One, this set will feel very familiar because they all draw from essentially the same CodeSignal question pool.

Here's a breakdown of all four problems for anyone preparing for upcoming CodeSignal assessments.

Problem 1: Highest Value Product

You're given two arrays: prices and ratings (ratings range from 1 to 5). Return the index of the product with the highest rating / price ratio. If multiple products have the same ratio, return the smallest index.

The solution is simply a single pass through the arrays while maintaining the current best ratio and its index. When two ratios are equal, keep the smaller index. To avoid floating-point precision issues, you can compare fractions using cross multiplication instead of division.

This is a classic warm-up problem that usually takes only a few minutes.

Problem 2: Bird Nest Building

The array represents branches scattered along a path. Positive integers indicate branch lengths, while 0 represents empty positions. A bird starts from one of the zero positions, repeatedly searches for the nearest branch on the right, then the nearest on the left, alternating directions until the total collected branch length reaches at least 100.

This is a straightforward simulation problem. Maintain the current search direction, locate the nearest available branch in that direction, add its length, set its position to zero, and switch directions.

The most common bug is failing to handle the situation where one side has no remaining branches. Make sure your simulation terminates correctly instead of entering an infinite loop.

Problem 3: Longest Diagonal Pattern

The matrix contains only the values 0, 1, and 2. Find the longest diagonal segment that starts with 1 and then follows the repeating pattern:

1, 2, 0, 2, 0, 2, 0, ...

The sequence must end exactly on the boundary of the matrix. All four diagonal directions need to be considered.

The typical solution is to enumerate every cell containing 1 as a starting point, then explore each diagonal direction while verifying that every element matches the required pattern.

Only update the answer if the entire sequence remains valid and the final position lies on the matrix boundary. Stop immediately when the pattern breaks.

The trickiest part is mapping each position in the traversal to the expected value in the repeating sequence, so it's worth writing that logic carefully before coding.

Problem 4: Unique Bytes Covered

Each operation provides an interval [start, end] representing received bytes. Intervals may overlap. After every insertion, output the total number of unique bytes covered so far.

This is the classic interval union problem.

Maintain an ordered collection of merged intervals. Whenever a new interval arrives, merge all overlapping ranges and update the total covered length accordingly.

Since the coordinate range can be very large, allocating an array is not feasible. An ordered map, balanced tree, or other dynamic interval structure is the intended solution.

Overall Thoughts

Once you're comfortable with the standard CodeSignal 70-minute format, the first two problems become warm-ups. Most of your time should be reserved for the third and fourth questions.

If you're preparing for companies that use CodeSignal, matrix traversal, simulation problems, and interval merging are three topics that deserve the most practice. These patterns appear repeatedly across assessments from HRT, TikTok, Uber, Visa, Capital One, and many other companies.

Preparing for CodeSignal Interviews?

At InterviewShow, we've organized a collection of 130+ real CodeSignal problems, including both the classic 70-minute coding assessments and the 90-minute OOD interviews.

Our materials cover interview patterns from companies including TikTok, Uber, HRT, Visa, Capital One, and many others, with company-specific practice lists instead of random LeetCode recommendations.

Learn more at: https://interviewshow.com

Good luck with your OA, and hope to see you on the other side of the interview process!

Intuit OA 2026 Guide: Code, SQL & Bash Questions Explained

interviewshow-cs — Fri, 31 Jul 2026 13:33:32 +0000

The Intuit Online Assessment (OA) has started rolling out again, and the format remains very similar to previous years. Most candidates receive three questions covering coding, SQL, and Bash scripting. We've helped candidates preparing for both Software Engineer and AI Engineer positions, and overall the assessment is quite manageable if you're familiar with the patterns.

Below is a complete breakdown of the three questions together with the solution ideas that helped candidates successfully pass the OA.

Question 1 — Student Arrangement

You are given an integer array where some positions contain 0, representing unknown values, while all other positions already contain fixed integers. Replace every zero with any integer so that the absolute difference between every pair of adjacent elements is at most one.

Return the number of different valid assignments modulo 1,000,000,007. The problem guarantees that at least one element is non-zero, and the array length is at most 1500.

Solution Idea

The key observation is to process each consecutive block of zeros independently. Existing numbers naturally divide the array into multiple segments, and each segment contributes independently to the final answer. The total number of valid arrays is simply the product of the number of valid assignments for every segment.

For one zero segment, the left and right boundaries (when they exist) are fixed values. This becomes a constrained walk from one endpoint to the other, where every step can increase by one, decrease by one, or remain unchanged.

Since the total displacement between the two endpoints is fixed, we enumerate how many +1, -1, and 0 moves appear in the segment. Every valid distribution can then be counted using multinomial (multiset) combinatorial formulas.

Special attention should be paid to:

Zero segments at the beginning or end of the array.
Segments whose endpoints differ too much, making the transition impossible.
Modulo arithmetic when multiplying segment counts.

Although it looks intimidating initially, this is essentially a combinatorics counting problem combined with interval decomposition.

Question 2 — SQL Capitalization Report

Write a SQL query that groups companies by sector and calculates the total market capitalization for each sector.

The output should contain:

sector
total_capitalization

The capitalization should:

Keep exactly two decimal places.
Display B for billions.
Display M for millions.
Sort results alphabetically by sector.

The original capitalization values are stored as strings such as:

Only companies with both a valid sector and a valid capitalization should be included.

Solution Idea

The solution is mostly string parsing followed by aggregation.

Filter out rows where the sector is NULL or capitalization equals n/a.
Extract the numeric portion and the unit suffix.
Convert B to billions and M to millions using multiplication.
Aggregate with SUM() grouped by sector.
Format the final result back into B or M with two decimal places.

The biggest pitfalls are unit conversion, preserving decimal precision, and formatting the final output correctly.

Question 3 — Bash Pattern Matching

Given an array of strings, count how many strings contain at least one uppercase English letter, then print the result to STDOUT.

Solution Idea

This is a straightforward Bash scripting question.

Iterate through every string and use a regular expression such as:

[A-Z]

If the pattern matches, increment the counter.

Remember to consider:

Empty strings
All lowercase strings
All uppercase strings
Mixed-case strings

This question can typically be solved in just a few lines of Bash.

Overall Difficulty

Compared with many other big tech online assessments, the Intuit OA is relatively friendly. The questions are practical and emphasize implementation rather than obscure algorithms.

Question 1 tests combinatorics and interval decomposition.
Question 2 focuses on SQL string processing and aggregation.
Question 3 is basic Bash scripting with regular expressions.

Candidates who have practiced common counting techniques, SQL data transformation, and simple shell scripting should find the assessment very manageable.

Preparing for More Tech Interviews?

Recruiting is still active across many major technology companies, including Amazon, Google, Microsoft, Meta, and TikTok. Besides online assessments, technical phone screens and virtual onsite interviews are also ongoing.

If you're preparing for upcoming interviews, Interview Show provides realistic mock interviews, OA guidance, and one-on-one interview coaching based on actual interview experiences from North American software engineering hiring processes.

Visit our website to learn more:

https://interviewshow.io

You can also browse more interview experiences, OA breakdowns, and preparation guides here:

https://interviewshow.io/blog

Good luck with your Intuit OA, and hopefully we'll see you in the interview rounds!

Bloomberg 2026 New Grad SDE Interview Experience | Full Interview Process from Phone Screen to Offer

interviewshow-cs — Thu, 30 Jul 2026 13:45:38 +0000

One of our students recently completed the entire Bloomberg Software Engineer New Grad interview process and received an offer. From the initial phone screen to the final offer call, the entire process took about one month. Bloomberg's interviews focus less on solving extremely difficult algorithm problems and more on communication, practical engineering skills, project discussions, and system design.

Below is a complete walkthrough of the interview process, including coding questions, behavioral interviews, system design topics, and preparation advice.

Interview Timeline

October 9 — Phone Screen
October 29 — Virtual Onsite (VO1 + VO2 + HR)
November 4 — Engineering Manager Interview
November 6 — Offer Call

Preparation Tips Before Interviewing

Communication is one of the biggest evaluation criteria at Bloomberg. Interviewers expect candidates to explain their thinking continuously while solving problems. Thinking out loud, discussing trade-offs, and communicating clearly are significantly more valuable than silently writing code. Long periods of silence often leave a poor impression.

Referral strategy also matters. Bloomberg verifies referral information shortly after applications are submitted. Candidates without referrals or target-school backgrounds may find the process considerably more difficult, so planning your application strategy beforehand can be worthwhile.

Instead of memorizing Bloomberg-specific LeetCode tags, focus on recognizing problem patterns. Bloomberg frequently presents familiar algorithmic ideas wrapped inside different business scenarios, making pattern recognition much more valuable than memorization.

Phone Screen

The interview started with several behavioral questions, including "Why Bloomberg?" and a discussion about the candidate's most challenging project.

Two coding problems followed.

The first was an easy graph problem involving a social network where candidates needed to find the first connection satisfying specific conditions.

The second problem was based on LeetCode 2062. The coding difficulty itself was relatively manageable. What mattered most was explaining the solution clearly, discussing complexity, and walking through edge cases while implementing the code.

Virtual Onsite Round 1

The interview began with project discussions and behavioral questions. The interviewer focused heavily on the most technically challenging portion of the project, how obstacles were overcome, and what improvements would be made if the project were redesigned today. A structured STAR response worked well for this portion.

The coding question centered around a probability scenario.

Imagine a television series with ten episodes. Users may leave after each episode. Given that 70% of users who finish a certain episode eventually complete all ten episodes, answer several probability-related questions involving the nth episode.

Although the mathematical difficulty was moderate, Bloomberg cared more about reasoning and edge-case analysis.

Several follow-up questions explored special cases:

What if every user leaves after the first episode?
What if every user watches all ten episodes?
How could an if-statement be rewritten to eliminate extra branching logic?

The final ten minutes were reserved for candidate questions, including discussions about work-life balance and commuting in New York. Before ending the call, the interviewer immediately scheduled the second virtual onsite round.

Virtual Onsite Round 2

After another project discussion, the interview shifted into an object-oriented design problem.

The task was to design a Tesla Equity system. Traders should be able to update daily prices or delete the latest price, while analysts should support the following operations:

Retrieve the latest price
Retrieve the maximum price
Calculate the average price

All operations were expected to run in O(1) time.

An object-oriented solution was recommended, separating the system into classes such as Equity, Trader, and Analyst while carefully organizing internal data structures.

A follow-up discussion referenced LeetCode 295 (Find Median from Data Stream). The interviewer mainly wanted to understand the design approach and data structure choices rather than requiring complete implementation.

Another ten-minute Q&A session followed, during which the candidate asked about the interviewer's daily responsibilities. The Engineering Manager interview was scheduled immediately afterward.

HR Interview

The HR interview consisted entirely of behavioral questions.

Tell me about a time you had disagreement with teammates.
Tell me about a time you learned something completely new.
Why Computer Science?
Why Bloomberg?
Tell me something not listed on your resume.

After the interview, HR confirmed that the feedback would be forwarded to the Engineering Manager for the final round.

Engineering Manager Interview

The Engineering Manager interview was the most technically demanding part of the process.

The primary question involved designing a distributed messaging system similar to Kafka.

The discussion covered multiple system design dimensions:

Producer
Consumer
Topics
Partitions
Brokers
Message SDK design
Retry mechanisms
Durability
Consistency
Availability

One particularly challenging scenario involved message ordering.

Suppose Producer A successfully sends data to Broker 1 while Producer B experiences network delays before also reaching Broker 1. How can the system guarantee message ordering?

The candidate did not fully answer this scenario. The Engineering Manager explained that a leader elected through the Raft consensus algorithm should determine message ordering while follower brokers replicate the committed log, ensuring consistent ordering across replicas.

Although the candidate initially felt this answer was incomplete, the interview extended beyond the scheduled time by nearly ten minutes. Before ending the conversation, the Engineering Manager even asked whether the candidate had any additional questions about relocating to New York, which turned out to be a very positive signal. Only two days later, Bloomberg reached out with the offer.

Overall Interview Experience

Bloomberg interviews emphasize practical engineering rather than purely difficult algorithms. Strong communication, deep project knowledge, structured problem-solving, and the ability to generalize familiar algorithmic patterns all play important roles throughout the process.

Candidates preparing for the Engineering Manager round should also review distributed systems fundamentals, especially Kafka architecture, Raft consensus, replication, consistency models, and messaging systems.

How Interview Show Helped

Before the onsite interviews, this candidate completed several targeted mock interviews focusing on Bloomberg's coding style and Engineering Manager system design expectations. During practice sessions, we emphasized structured communication, explaining implementation choices clearly, and decomposing distributed systems into manageable components.

The Kafka system design question closely resembled topics covered during mock interviews. Although every follow-up question could not be answered perfectly, the candidate maintained a logical discussion framework throughout the conversation instead of becoming stuck, which significantly improved overall interview performance.

Interview Show specializes in technical interview preparation for North American software engineering positions. Our team includes engineers with experience at leading technology companies and provides personalized interview coaching, coding interview preparation, virtual onsite mock interviews, and system design guidance. For companies like Bloomberg, Citadel, Jane Street, and other finance-focused engineering teams, we also offer company-specific preparation tailored to each interview style.

Google New Grad Interview Question: Subarray Sum Modulo K (Prefix Sum + Hash Set)

interviewshow-cs — Wed, 29 Jul 2026 08:37:34 +0000

I recently helped a candidate review their Google New Grad coding interview, and one of the questions was a classic algorithm disguised with a slightly unusual statement. Although the wording looks different, once you recognize the underlying pattern, the solution becomes straightforward.

The Problem

Given a positive integer array nums and an integer k, determine whether there exists a non-empty contiguous subarray whose sum modulo 6,000,009 equals k.

Key Insight

Whenever you see contiguous subarray sum, think about prefix sums.

Let

prefix[i] = sum of the first i elements

Then the sum of subarray (i, j] is

prefix[j] - prefix[i]

The problem requires

(prefix[j] - prefix[i]) % M == k

where

M = 6,000,009

Rearranging the equation gives

prefix[i] % M == (prefix[j] - k) % M

Therefore, while scanning the array, we only need to keep track of all previously seen prefix sum remainders. For the current remainder cur, if we've already seen

(cur - k) % M

then we've found a valid subarray.

Python Solution

def HasSubarrayKMod(nums, k):
    M = 6_000_009
    k %= M

    seen = {0}      # Empty prefix handles subarrays starting at index 0
    cur = 0

    for x in nums:
        cur = (cur + x) % M

        if (cur - k) % M in seen:
            return True

        seen.add(cur)

    return False

Complexity Analysis

Time Complexity: O(n)
Space Complexity: O(n)

Common Interview Pitfalls

Initialize the hash set with remainder 0. Otherwise, you'll miss subarrays that start from the first element.
Normalize k by taking k %= M before processing.
Explain why prefix sums work before writing code. Google interviewers care just as much about your reasoning as your implementation.

Interview Tips

Google New Grad coding interviews frequently present classic algorithms in unfamiliar forms. Whenever you encounter phrases like "subarray sum" together with "modulo", your first instinct should be prefix sums + remainder hashing. This pattern appears repeatedly across interview problems and is one of the standard techniques every candidate should master.

Rather than memorizing solutions, practice recognizing patterns such as prefix sums, hash maps, sliding windows, and two pointers under time pressure. Being able to clearly explain your thought process while coding often makes a bigger difference than simply arriving at the correct answer.

Need More Google Interview Practice?

If you're preparing for Google New Grad interviews and want realistic mock interviews, coding walkthroughs, or real-time interview assistance, check out Interview Show. Many candidates report significant improvements in problem recognition, communication, and interview performance after targeted preparation.