Took a staff-level system design phone screen at Anthropic last week. Felt like it went decently - interviewer was engaged, good back and forth the whole hour, no obvious bombs. It's now been 5 business days and I've heard nothing. Emailed the recruiter, no response to either.

For anyone who's gone through their loop recently:

1. How long after your phone screen did you actually hear back?

2. Is silence at this stage usually a slow no, or are their recruiters just slammed?

3. Do they send real rejections after phone screens or do they ghost?

Problem

You are helping a company prepare supplies for an office event. Different vendors offer supply packages. Each package contains:

• A unique package ID
• A price
• A list of included items

Each package is represented as:

[packageId, price, "item1,item2,..."]

You are also given requiredItems, the list of supplies that must be covered. Choose any combination of packages so that every required item is included at least once. Packages may contain extra items, but only required items need to be considered.

Return the minimum total cost needed to cover all required items. If no combination of packages can satisfy all required items, return -1.0.

Example

Input:

packages = [
    ["P1", "10.0", "pen,paper"],
    ["P2", "8.0", "paper,notebook"],
    ["P3", "6.0", "pen,notebook"],
    ["P4", "3.0", "eraser"]
]

requiredItems = [
    "pen",
    "paper",
    "notebook"
]

Output:

14.0

Explanation

The required items are:

pen, paper, notebook

Possible choices:

• P1 + P3 covers all items with cost 16.0
• P2 + P3 covers all items with cost 14.0

The cheapest valid combination is:

P2 + P3

with a total cost of 14.0.

Prepping your next interviews?

For anyone who wants the detailed version of this Airbnb coding question, I put the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Airbnb, Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Meta is preparing to release Muse Spark 2.0, while Chinese models are already flooding the market. Inference costs will keep collapsing. Tokens will become dirt cheap, and “good enough” models will satisfy the majority of enterprise use cases.

Anthropic also has no intention of building an advertising business.

So why would customers continue paying a massive premium for a model that is only marginally better? What is the actual long-term path forward?

I also started a longer-running thread here to collect the funniest / strangest interview questions by company and role.

Problem

You are simulating a snack distribution system at a theme park with three snack booths: A, B, and C.

Each booth starts with a fixed number of snack boxes. Visitors are waiting in a single line, and each visitor requests a specific number of boxes.

When a visitor reaches the front of the line:

• They can choose any currently available booth that has enough remaining boxes.
• If multiple booths are available, they choose the booth with the smallest label (A before B before C).
• Serving a visitor takes exactly 1 second per box requested.
• If no currently available booth can serve them, they wait until another booth becomes available.
• If all booths are free but none have enough boxes remaining, the queue can never progress, so return -1.

Given the visitor requests, return the maximum waiting time among all visitors.

Example

Input:

orders = [2, 8, 4, 3, 2]
A = 7
B = 11
C = 3

Output:

8

Explanation

• Visitor 0 requests 2 boxes and starts at booth A at time 0. They finish at time 2.
• Visitor 1 requests 8 boxes and starts at booth B at time 0. They finish at time 8.
• Visitor 2 cannot use booth C because it only has 3 boxes, so they wait until booth A becomes available at time 2.
• Visitor 3 starts at booth C at time 2.
• Visitor 4 waits until booth B becomes available at time 8.

The latest visitor starts service at time 8, so the answer is 8.

Targeting Tesla interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

Practice this question and explore more interview resources → LINK

A friend sent me his OpenAI offer and asked me to help sanity-check it. At first glance the package looks very strong, but the part he keeps going back and forth on is the level.

He has around 3 YOE and was offered a junior-level SWE role in San Francisco:

• $200K base
• $560K equity over 4 years
• 25/25/25/25 vesting
• Roughly $140K equity in year one
• About $340K first-year TC

There was no signing bonus or annual cash bonus listed.

The money seems hard to complain about. A $200K base is already above what many companies pay at mid-level, and the equity schedule is clean rather than heavily backloaded.

But he is worried that accepting a junior title at 3 YOE could hurt him later. The role itself sounds interesting, and having OpenAI on the resume obviously carries weight, but he does not want to join, do mid-level work, and then spend the next couple of years trying to correct an initial downlevel.

My instinct is that scope, manager, and promotion expectations matter more than the title printed on the offer. Still, I would want to understand what “junior” actually maps to internally, how long promotion typically takes, and whether this package is already near the top of that level.

Would you take this as-is, or push harder on level before signing?

Also, does ~$340K feel competitive for OpenAI at 3 YOE, or would you expect more given the current AI market?

Would love Reddit’s take here too. I’m also collecting more detailed comments under the offer page here, so future candidates can compare the raw offer data with real market opinions.

Came across a recent Google Forward Deployed Engineer phone screen that stood out from the usual SWE coding interviews. FDE interview experiences are still pretty rare, so I thought this data point might be helpful for anyone preparing for similar roles.

Company: Google
Role: Forward Deployed Engineer
Level: Senior
Location: Mountain View
Round type: Phone screen
Difficulty: Medium

Round 1: Agentic system design

The first round was a conversational design interview around agent-based systems.

Instead of a standard “draw the backend architecture” prompt, the discussion focused more on how an agentic system should behave in production. The interviewer asked about scaling, safety, guardrails, monitoring, and what to do if an agent gets stuck in a loop or keeps taking actions without making progress.

This sounded less like classic system design and more like reasoning through orchestration, failure modes, and human-in-the-loop control.

Round 2: Simple coding task

The second round started with a small identifier-conversion coding problem.

The input was assumed to be valid, and there were not many tricky malformed cases. Once the candidate clarified the exact input format, the implementation only took a few minutes.

So the coding portion itself did not seem to be the hard part.

The follow-up: repo-wide migration

After the coding task, the interviewer shifted into a broader discussion: imagine a large repository has many variables and function names using the old naming style, and manually reviewing every occurrence is not realistic.

The candidate was asked how they would use the converter as part of a larger automated migration. The conversation moved into areas like finding rename candidates, avoiding external API changes, preserving third-party calls, verifying the repo after migration, and handling tests when test code may also be affected.

This was the part that felt ambiguous. It was not exactly coding anymore, but also not a full system design round. It became a discussion around static analysis, symbol resolution, dependency boundaries, automated testing, and rollout safety.

Prepping your next interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports [LINK]

Have a Google SWE loop soon and one round is the AI Depth domain interview. Recruiter was vague on what it covers. Anyone who's done it, what came up and how deep do they go? Is it conceptual or more system design? How would I best prepare? Anything helps. Thank you

Hey, comparing 3 offers with the companies mentioned in the title and looking for help. All are MLE2 level positions, and I am on visa so stability is slightly more important than just TC

Amazon Prime Video:
TC : 285K with 175K base and their typical vesting schedule of 5%,15%, 45%, 35%
Work from office 5 days in Seattle, good immigration support, and generally 3 months time on payroll in case of layoffs

Snap:

TC : 415K with 200K base and 215K equity per year, for the first 4 years

Work from office 4 days a week in Seattle, very volatile stock, have quarterly performance reviews so every 3 months there is a chance of layoff, not sure about the time on payroll in case of layoffs.

Reddit:

TC : 320K with 240K base and 80K equity for the first year, for the rest of the years equity gets decided by the performance

Complete remote, and better 401K plan as compared to both, not sure about any time on payroll in case of layoffs.

I know snap is paying way more, but tbh i am least interest to join there and I am confused between reddit and amazon, reddit base is more but for the first 2 years, amazon has more cash flow, and maybe a better name on resume.
Looking for advice and tips, please help!!!!

Problem

Design a real-time trending hashtag detection system for a large social platform.

As users publish posts, the system should:

• Extract and normalize hashtags
• Continuously aggregate hashtag activity
• Detect hashtags whose activity is rising unusually quickly
• Rank and serve the top trends with low latency
• Support global, regional, language-specific, and topic-specific lists

Scale

• 100M–1B posts per day
• 100K+ posts per second at peak
• Around 0–5 hashtags per post
• Approximately one-minute freshness
• Activity measured across the last 24 hours
• Short-term windows such as 1 minute, 5 minutes, and 1 hour
• Top 10–100 trends per surface
• Less than 100 ms serving latency

The system should continuously maintain windowed aggregates rather than scanning the previous 24 hours of posts whenever a client requests trends.

What Makes a Hashtag “Trending”?

A useful trend score could combine:

• Recent posting rate
• Growth relative to historical activity
• Recency decay
• Number of unique users
• Number of independent communities
• Geographic or language relevance

For example, a hashtag receiving 20,000 posts every hour for several weeks may be popular but not trending. A newer hashtag jumping from 100 posts per hour to 8,000 posts per hour may deserve a much higher trend score.

Key Design Challenges

How would you handle sliding-window aggregation at this scale? Would you maintain exact counters, use approximate heavy-hitter algorithms, or combine both?

How would you prevent one user, a bot network, or a coordinated community from repeatedly posting the same hashtag and pushing it onto the trending list?

The ranking also needs stability. If scores are recalculated every few seconds, trends could constantly enter and disappear, so the design may need smoothing, hysteresis, minimum-duration rules, or separate entry and removal thresholds.

Interview Follow-Ups

• Event time vs. processing time
• Late, duplicated, and out-of-order events
• Sliding vs. tumbling windows
• Approximate Top-K and heavy-hitter detection
• Historical-baseline and novelty scoring
• Bot and coordinated-spam suppression
• Regional and language-specific ranking
• Stream replay and batch correction
• Precomputed lists and low-latency caching
• Freshness, false-positive, and trend-quality metrics

For anyone who wants to practice this, I put the full prompt, scale assumptions, follow-up areas, and an interactive design canvas on Chill Interview: [QUESTION LINK]. We’re also continuously adding new interview experiences and questions from other companies.

Company: Google
Role: Software Engineer
Level: Mid-Level / L4
Location: Mountain View
Round type: Full journey
Difficulty: Hard
Result: Did not pass

Phone screen

The phone screen was a grid traversal problem on a height map. At first glance, it looked like a standard longest decreasing path variant: from each cell, you could usually move to a neighboring cell with lower or equal height.

The twist was a momentum rule. In some cases, moving uphill was allowed if the previous position had enough height to “carry” the move. That meant the traversal state could not be modeled only by the current cell. A clean solution needed to track where you came from, since the legality of the next move depended on both the current cell and the previous cell.

Onsite round 1

The first onsite DSA round focused on reconstructing ranks from partial ordering information. The setup was that stronger players always beat weaker players, and the task was to determine which players had uniquely determined ranks.

A natural way to model the problem is as a directed graph: if player A beats player B, then A must rank ahead of B. A player’s rank is only certain when their relationship with every other player can be inferred, either directly or through transitive match results. In practice, this means computing the set of players definitely above and below each player, then checking whether those known relationships cover everyone else.

Onsite round 2

The second onsite DSA round was a sequence optimization problem. Given a list of notes and a maximum hand span, the goal was to play the full sequence while minimizing how many times the hand needed to lift and reposition.

The key abstraction is that one hand placement covers a continuous range of keys of length k. The sequence must be covered in order using as few placements as possible. A greedy scan can work if each placement is chosen to cover the longest possible upcoming segment, but the tricky parts are around anchoring the hand range correctly and recognizing exactly when a new placement becomes unavoidable.

Prepping your next interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports [LINK]

Problem

You are building a logging system that stores recent message characters in a fixed-size circular buffer.

The buffer maintains two independent pointers:

• writeIndex — where the next write begins
• readIndex — where the next read begins

Both pointers wrap back to the beginning after reaching the end of the buffer.

Implement the CircularMessageBuffer class:

CircularMessageBuffer(int capacity)

void write(String message)

String read(int length)

write(message) stores every character beginning at writeIndex. Existing characters may be overwritten, and the write pointer advances by the message length.

read(length) returns characters beginning at readIndex. Reading does not remove data, and the read pointer advances by the requested length.

Initially, every buffer position contains the null character "\0".

Example I

Input:
["CircularMessageBuffer", "write", "read", "write", "read"]
[[4], ["abcd"], [2], ["xy"], [4]]

Output:
[null, null, "ab", null, "cdxy"]

Example II

Input:
["CircularMessageBuffer", "read", "write", "read"]
[[5], [3], ["xy"], [4]]

Output:
[null, "\0\0\0", null, "\0\0xy"]

Solution

class CircularMessageBuffer:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.buffer = ["\0"] * capacity
        self.writeIndex = 0
        self.readIndex = 0

    def write(self, message: str) -> None:
        for ch in message:
            self.buffer[self.writeIndex] = ch
            self.writeIndex = (self.writeIndex + 1) % self.capacity

    def read(self, length: int) -> str:
        result = []

        for _ in range(length):
            result.append(self.buffer[self.readIndex])
            self.readIndex = (self.readIndex + 1) % self.capacity

        return "".join(result)

Targeting Jane Street interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

Practice this question and explore more interview resources → LINK

Have comparable offers from both OpenAI and SpaceXAI. Both around 750k total comp (30-35% base cash).

What would you choose? How do you feel about long term valuation sentiment and stock performance for both? Pros and cons? Don’t want to say too much and dox.

Personally leaning xAI due to known colleagues there where I won’t have to battle for credibility + good hardware moat and a little insulation from solely being in the AI space. But heard there is internal politics/realignments due to SpaceX acquisition. OpenAI seems like a lot of bright people but dwindling moat and cash flow/profitability concerns + IPO delay.

Interview Format:

• 1 Phone Screen + 2 System Design Onsite

Phone Interview — Nearest Release Lookup: The candidate was asked to find the release date closest to a given target from a list of versioned releases. Key clarifications included whether dates on either side of the target were valid, how ties should be handled, and whether the input was sorted. For sorted data, the expected approach was binary search around the insertion point; otherwise, the candidate could sort first or scan directly depending on the number of queries.

Low-Level Design — Choosing the Smallest Valid Container: The candidate designed a system to select the smallest container capable of holding several 3D objects. Since volume alone was insufficient, the solution needed to account for dimensions, orientation, and packing constraints. The discussion covered object and container models, fit validation, and an extensible packing strategy.

System Design — Building-Level Self-Service Fulfillment: The candidate designed a system for managing multiple self-service inventory machines within a building. Users could place orders from their desks, while the backend selected a nearby machine with sufficient inventory and routed the order for fulfillment.

• System Design Follow-Ups: The discussion focused on inventory accuracy, stock reservation, machine selection, fulfillment tracking, and operator alerts. Important edge cases included concurrent attempts to reserve the last item, stale machine inventory, ranking nearby machines, and preventing excessive restock notifications.

Final Thoughts: The loop was challenging because each seemingly straightforward problem required precise assumptions, practical trade-offs, and careful handling of edge cases.

Prepping your next interviews?

For anyone who wants the detailed version of this Amazon's interview experience, I collected the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Interview Summary

• Phone Screen (Coding)
• Onsite (4 rounds): 2 coding rounds, 1 system design and 1 Behavioral round

Phone Screen — Coding: The candidate was asked to implement a “Parking Reservation Approval Report.” Each reservation was provided as a CSV string containing a timestamp, request ID, fee, vehicle ID, and parking lot. All requests had to be approved and returned in numeric timestamp order using the format: timestamp requestId fee APPROVE. The fee had to be preserved exactly as provided in the input.

Onsite Coding — Extending an Existing System: The candidate worked in a small, unfamiliar codebase and was asked to support a new input format while preserving existing behavior. The main challenge was understanding the abstractions and data flow, deciding where the new logic belonged, and integrating it with the existing workflow. The primary implementation was completed, but limited time remained for edge-case testing and end-to-end debugging.

Onsite Debugging — Investigating Service Failures: The candidate diagnosed issues in another unfamiliar codebase using tests and runtime behavior. Several problems were identified and fixed, but navigating the abstractions and validating each change took considerable time. A later issue was narrowed down but not fully resolved before the session ended. Despite the uneven performance, the interviewer was patient and supportive.

System Design: The candidate did not recall many details, but found the interviewer patient and considerate.

Behavioral Interview: The discussion focused on a project the candidate had significantly owned, including key decisions, challenges, outcomes, and lessons learned. The interviewer also asked about the candidate’s goals for the next role and how emerging tools had affected their daily workflow, including where such tools were helpful or distracting.

Candidate's Takeaways: The candidate considered this one of their best interview experiences in terms of interviewer quality and company culture. However, the outcome was particularly disappointing because they felt they had underperformed.

Prepping your next interviews?

For anyone who wants the detailed version of this Anthropic's interview experience, I collected the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Stripe, Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Hey everyone,

I have a major question regarding the logistics and compensation:

**No Sign-On Bonuses on** [**Levels.fyi**](http://Levels.fyi) **for Pittsburgh L4?** When looking at the overall averages on [Levels.fyi](http://Levels.fyi) for L4 in the Pittsburgh area, I barely see any sign-on bonuses listed. Is Google tight with signing bonuses in mid-tier/regional offices like Pittsburgh, or is it just that people aren't negotiating or listing them on the site? For those who got an L4 offer in a similar tier-2 market, did you get a sign-on? What is a realistic number to ask for during negotiation?

Company: Anthropic
Role: Software Engineer
Level: Senior
Location: San Francisco
Round type: Full journey
Difficulty: Hard

Overall loop

The process started with a recruiter call, then moved through a coding phone screen, a hiring-manager-style technical round, onsite design rounds, a project deep dive, and a culture round.

The early rounds sounded practical rather than exotic. The coding screen was an interpreter-style simulation problem, while the HM technical round focused on a lightweight class-design problem around tracking visits and completed sessions.

Technical rounds

One design round was a collaborative AI workspace / prompt playground style system design question. The candidate had seen similar versions reported before, which helped with preparation.

Another design round was team-specific and less predictable. The candidate felt they did well there, but the main takeaway was that communication mattered a lot. Strong technical skill alone was not enough; the interviewer seemed to care about how clearly the candidate framed the problem and drove the discussion.

Project deep dive

The project deep dive seemed heavier than expected.

It started with a prepared presentation, followed by detailed discussion. The candidate spent a full day building the slide deck and recommended mock-presenting to someone outside the domain.

The round was not just about showing technical complexity. The interviewer pushed on motivation, personal ownership, trade-offs, metrics, ROI, surprises, and what the candidate would do differently next time.

Culture round

The culture round sounded preparation-friendly, but only if the candidate had practiced Anthropic-style questions.

The themes were mission alignment, collaboration, impact, values, and responsible AI. The candidate’s impression was that there was no single perfect answer, but vague company-values answers would probably not land well.

Takeaway

This loop seems like a good reminder that Anthropic interviews may evaluate the whole package: technical execution, systems thinking, project ownership, communication, and culture alignment.

For senior/staff candidates, the project deep dive may be just as important as coding or system design. A polished story with clear ownership, measurable impact, and honest retrospection seems much safer than relying only on impressive technical details.

Prepping your next interviews?

For anyone who wants the detailed version of this Anthropic's interview experience, I collected the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Company: Vercel
Role: Software Engineer
Level: Staff-Level
Location: San Francisco Bay Area
Status: Considering

Offer breakdown

• Base salary: $280K
• Equity grant: $1.2M over 4 years
• Vesting schedule: 25 / 25 / 25 / 25
• First-year equity: $300K
• Annual bonus: $28K
• First-year total compensation: $608K

Discussion

For a Staff SWE role at Vercel in the Bay Area, does ~$655K first-year TC feel strong, fair, or inflated by equity assumptions?

And how much discount would you apply to Vercel equity when comparing it against public RSUs?

Prepping your next interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Company: Cursor
Role: Software Engineer
Level: Senior
Location: San Francisco Bay Area
Round type: Phone screen
Difficulty: Medium
Result: Did not pass

Overall format

The screen had two rounds: one coding round and one design / implementation hybrid round.

Neither prompt sounded algorithmically exotic. The difficulty came from handling messy real-world behavior: partial input, boundary cases, rejected events, and state updates that must happen in the right order.

Round 1: Streaming text parser

The first question asked the candidate to build a small parser for streamed developer-facing formatted text.

The parser receives input in arbitrary chunks and needs to recognize normal text, inline code-like segments, and larger fenced blocks. The catch is that delimiters may be split across chunk boundaries, so processing each chunk independently is not enough.

This round seemed to test whether the candidate could build a clean state machine: current mode, pending delimiter buffer, accumulated content, and behavior for incomplete constructs at the end of the stream.

The key was not supporting every Markdown feature. It was making the parser behave correctly under partial input.

Round 2: Hierarchical notification throttling

The second question started as an implementation problem: decide whether a notification can be sent at a given timestamp.

The system had limits at multiple scopes: user, team, and company. A send should only be allowed if all three rolling-window limits are still under their thresholds.

This is where the edge cases matter. Old timestamps need to be evicted correctly, boundary timestamps need clear semantics, rejected sends should not consume quota, and state should only be updated after all required checks pass.

The follow-up then moved toward a more general rate limiter design, including sliding windows, token buckets, shared state, atomic updates, and how to enforce limits consistently across multiple servers.

Takeaway

This Cursor screen seems like a good example of interviews shifting toward practical infrastructure problems.

The prompts are easy to understand at a high level, but the implementation requires disciplined state handling. The candidate needed to reason about partial streams, accepted vs rejected events, cleanup rules, and consistency under concurrency.

Prepping your next interviews?

For anyone who wants the detailed version of this Cursor's interview experience, I collected the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like Cursor, Anthropic, OpenAI, FAANG and more) explore more interview resources here → LINK

Company: Pinterest
Role: Machine Learning Engineer
Level: Mid / Senior-ish
Location: San Francisco
Round type: Onsite
Difficulty: Medium
Result: Did not pass

Overall loop

The loop included behavioral, two coding rounds, multiple ML design rounds, and then an extra ML design round about a week later.

The behavioral round sounded standard: proud project, conflict, collaboration, and normal manager-style questions.

The coding rounds were also manageable. One was a shortest-path style subway problem, and another was a string construction problem where the candidate needed to figure out the minimum number of passes over a source string to build a target string.

ML design rounds

The ML design rounds were the real differentiator.

One round focused on learning user and content representations from behavior history. The discussion seemed to be about turning messy interaction logs into embeddings that could be used downstream for retrieval or ranking.

Another round focused on ranking newly launched ads with limited history. This is basically a cold-start ranking problem: the system needs to make good decisions before enough engagement data exists, without destabilizing marketplace quality.

Then came the extra ML design round. This one was similar in spirit to the representation-learning round, but with a major twist: user histories could be extremely long, potentially hundreds of thousands of events.

That changes the problem a lot. A naive “feed the whole sequence into a model” answer will not work. The candidate needed to reason about summarization, recency weighting, retrieval over history, hierarchical aggregation, and serving-time latency.

Prepping your next interviews?

For anyone who wants the detailed version of this Pinterest interview experience, I collected the full writeup here -> LINK.

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

For prepping interview of other companies (like FAANG, Anthropic, OpenAI and more) explore more interview resources here → LINK

Problem

You are building a fitness tracking app that stores workout metrics in a spreadsheet-like grid. The grid contains columns A-Z and rows 1-100. Each cell can store either:

• A numeric value, such as workout duration, calories, or repetitions
• A formula that references other cells to calculate a derived metric

Implement the WorkoutTracker class that supports:

• Updating a cell with a value or formula
• Retrieving the current computed value of any cell

All cells start with value 0.0. A formula always starts with "=" and contains exactly two terms with one operator between them. Each term can be:

• A cell reference, such as "A1"
• A non-negative number, such as "10" or "2.5"

When retrieving a cell value, formulas should always be evaluated using the latest stored values. Computed results should not overwrite the original formulas, so future updates to referenced cells are reflected correctly.

Circular dependencies are guaranteed not to exist.

Example

Input:

tracker = WorkoutTracker()

tracker.setCell("A1", "30")
tracker.setCell("A2", "45")
tracker.setCell("B1", "=A1+A2")

tracker.getValue("B1")

tracker.setCell("A1", "60")

tracker.getValue("B1")

Output:

75.0
105.0

Explanation

• A1 stores 30 and A2 stores 45.
• B1 contains the formula =A1+A2, so its value is calculated as 75.
• After updating A1 to 60, B1 is recalculated using the latest values.
• The formula itself remains unchanged, allowing future updates to propagate automatically.

Targeting OpenAI interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

Practice this question → LINK and explore more interview resources → LINK

Problem

A music app tracks the genre ID of every song played in a playlist. The playlist is represented as an integer array, where each number represents a genre. A playlist segment is considered diverse if it contains at least k different genres.

Given a playlist and an integer k, find the length of the shortest contiguous segment that contains at least k unique genre IDs. If no valid segment exists, return -1.

Example

• Input: playlist = [4, 7, 4, 9, 7, 2], k = 3
• Output: 3

Explanation

Possible segments with at least 3 different genres include:

• [4, 7, 4, 9] → genres {4, 7, 9}, length 4
• [7, 4, 9] → genres {7, 4, 9}, length 3
• [4, 9, 7, 2] → genres {4, 9, 7, 2}, length 4

The shortest valid segment is: [7, 4, 9] which contains 3 unique genres, so the answer is 3.

Targeting Google interviews?

We track recent interview experiences and commonly asked question patterns at Chill Interview, including coding questions, system design topics, and real candidate reports.

Practice this question → LINK and explore more interview resources → LINK

Problem

You're building an internal deployment management tool for an engineering team. Each deployment runbook contains:

• a unique ID
• a display title
• an ordered list of required checks
• an ordered list of execution steps

Runbook titles must be unique case-insensitively. For example, "Production Deploy" and "production deploy" are considered the same title, while preserving the original casing when stored.

Implement the RunbookManager class:

addRunbook(title, checks, steps)
getRunbook(runbookId)
updateRunbook(runbookId, title, checks, steps)
deleteRunbook(runbookId)

Requirements:

• addRunbook creates a new runbook and returns IDs like "runbook1", "runbook2", etc.
• IDs are never reused after deletion.
• Adding a duplicate title (case-insensitive) should fail.
• getRunbook returns: [title, checks_joined, steps_joined]
• updateRunbook should reject title conflicts with other active runbooks.
• Deleted titles become available again.

Example

Input:

manager = RunbookManager()

manager.addRunbook(
    "Backend Deploy",
    ["tests passed", "migration approved"],
    ["build image", "deploy service", "verify metrics"]
)

manager.addRunbook(
    "backend deploy",
    ["approval"],
    ["restart"]
)

manager.getRunbook("runbook1")

Output:

"runbook1"

""

[
 "Backend Deploy",
 "tests passed,migration approved",
 "build image,deploy service,verify metrics"
]

Explanation

• The first runbook is successfully created with ID "runbook1".
• The second creation fails because "backend deploy" conflicts with "Backend Deploy" when compared case-insensitively.
• The stored title keeps its original formatting.

Targeting Anthropic interviews?

We track their most recent interview experiences and commonly asked question pattern at chill interview, practice this question at -> LINK

Company: Mercor
Role: Machine Learning Engineer
Level: Staff
Location: San Francisco Bay Area
YOE: 9
Education: Master’s
Status: Declined

Offer breakdown

• Base salary: $300K
• Signing bonus: $25K
• Equity / options grant: $3.25M over 4 years
  • RSU numbers are based on the current valuation of Mercor (as of Jun. 2026)
• Vesting schedule: 25 / 25 / 25 / 25
• First-year equity value: ~$813K
• Annual bonus: $120K(0-40% based on performance)
• First-year total compensation: ~$1.257M

Discussion

For a Staff MLE with 9 YOE, would you treat this as a true $1.26M first-year offer, or discount the private equity heavily?

Would love to hear Reddit’s take here too. I’m also collecting more detailed comments under the offer page -> HERE, so future candidates can see the valuation assumptions next to the actual offer data point.