Round 1: Invent and Simplify, Dive Deep
Coding Focus: Data Structures and Algorithms

In the first round, the emphasis was on my ability to invent and simplify solutions while diving deep into complex problems. The challenge presented was to implement an LRU (Least Recently Used) Cache.

Problem
Design and implement an LRU Cache with the following operations:

get(key): Retrieve the value of the key if it exists in the cache.
put(key, value): Insert or update the value of the key. If the cache reaches its capacity, it should invalidate the least recently used item.
Round 2: Customer Obsession, Ownership
Coding Focus: Writing Logical and Maintainable Code

The second round assessed my qualities of customer obsession and ownership. The task was to implement an agent that periodically fetches memory utilization metrics.

Problem
Implement an agent in Java that calls an API every 10 seconds to fetch the memory utilization for serviceB. Assume an API call systemB() is provided, which returns the metric.

Round 3: Learn and Be Curious, Deliver Results
Coding Focus: Problem Solving

The third round focused on my ability to learn and be curious while effectively delivering results. The problem dealt with correcting input strings where users might omit spaces.

Problem
When searching for products, even if there's no direct match for an input string, we still want to show relevant results. In situations where customers accidentally omit spaces between words (e.g., "thisisawesome"), develop an algorithm that finds potential word boundaries and outputs the corrected string (e.g., "This is awesome").

Round 4: Have Backbone; Disagree and Commit, Earn Trust
Focus: System Design

The final round was a system design interview that evaluated my ability to have backbone, disagree and commit, and earn trust through well-thought-out solutions.

Problem
You own a service with a few (say, 5) customer-facing APIs, and you want to know the latency of each API. You aim to determine the P50, P90, P99, and P100 latency percentiles. Design a metrics collection and aggregation service that is highly reliable, scalable, and has low end-to-end latency.