Meta software engineer interviews cover algorithms, data structures, system design, and coding problems drawn from real interview rounds.
Question Your task is to implement a simple in-memory cloud storage system that maps objects (files) to their metadata (name, size, etc.). You...
Input: Graph (nodes and edges)Question Design a banking system that supports account management, transactions, and various financial operations.
Input: Graph (nodes and edges)Question Given a list of strings, find the minimum subset of prefixes that can represent the entire input set. A string is "represented" if it...
Input: Array of stringsDescription Implement a simplified in-memory database that supports record manipulation with various operations. The system should handle basic...
Input: Graph (nodes and edges)Question You are monitoring the building density in a district of houses. The district is represented as a number line, where each house is located...
Input: Array of integers+ and -, and parentheses ( and ), simplify...Input: StringScenario
Part 1 — Default delivery safeguards
id, timestamp, tenant, sender, recipient, campaign, and bytes. timestamp is an integer number of seconds and bytes is the nonnegative payload size, both encoded as strings.timestamp order, breaking ties by ascending ASCII id. Return decisions in that order, regardless of input order.payload_size: a message may contain at most 1000 bytes.sender_rate: each (tenant, sender) may admit at most 3 messages in a rolling 60-second window.recipient_rate: each (tenant, recipient) may admit at most 2 messages in a rolling 60-second window.t, a window of width w contains previously admitted messages with timestamps in (t - w, t], plus the current message when calculating projected usage. Earlier processed messages at the same timestamp count.id, status (ADMITTED or REJECTED), and violations.evaluate_messages(messages: list[dict[str, str]]) -> candidate_definedExample 1:
{
"messages": [
{"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"400"},
{"id":"m2","timestamp":"1","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"600"},
{"id":"m3","timestamp":"2","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"100"},
{"id":"m4","timestamp":"3","tenant":"T","sender":"a","recipient":"y","campaign":"C","bytes":"1000"},
{"id":"m5","timestamp":"4","tenant":"T","sender":"a","recipient":"z","campaign":"C","bytes":"100"},
{"id":"m6","timestamp":"5","tenant":"T","sender":"b","recipient":"z","campaign":"C","bytes":"1001"}
]
}[
{"id":"m1","status":"ADMITTED","violations":[]},
{"id":"m2","status":"ADMITTED","violations":[]},
{"id":"m3","status":"REJECTED","violations":["recipient_rate"]},
{"id":"m4","status":"ADMITTED","violations":[]},
{"id":"m5","status":"REJECTED","violations":["sender_rate"]},
{"id":"m6","status":"REJECTED","violations":["payload_size"]}
]m3 would be the third admitted message to recipient x, exceeding 2. Because it is rejected, m4 becomes sender a's third admitted message and is allowed, including its exactly-1000-byte payload. m5 would be sender a's fourth message. m6 exceeds the payload limit by 1 byte.Part 2 — Configurable overlapping budgets
extra_rules, a list of maps whose keys and values are strings. Each map contains id, group_by, metric, window_seconds, and limit.group_by is a comma-separated list of distinct fields chosen from tenant, sender, recipient, and campaign, with no whitespace. All fields together form the rule's grouping key.metric is either messages, contributing 1 per admitted message, or bytes, contributing the message's payload size. window_seconds is a positive integer string; limit is a nonnegative integer string.rule, numeric projected, and numeric limit, sorted by rule ID. For payload_size, projected usage is simply the current payload size.admitted_totals containing numeric messages and bytes. These totals include all admitted messages in the batch, even if their rolling-window entries later expire.decisions and admitted_totals; an equivalent typed representation is acceptable.evaluate_with_rules(messages: list[dict[str, str]], extra_rules: list[dict[str, str]]) -> candidate_definedExample 2:
{
"messages": [
{"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"700"},
{"id":"m2","timestamp":"10","tenant":"T","sender":"b","recipient":"y","campaign":"C","bytes":"600"},
{"id":"m3","timestamp":"20","tenant":"T","sender":"c","recipient":"z","campaign":"C","bytes":"300"},
{"id":"m4","timestamp":"30","tenant":"T","sender":"c","recipient":"z","campaign":"D","bytes":"200"},
{"id":"m5","timestamp":"60","tenant":"T","sender":"d","recipient":"w","campaign":"C","bytes":"700"}
],
"extra_rules": [
{"id":"tenant_bytes","group_by":"tenant","metric":"bytes","window_seconds":"60","limit":"1500"},
{"id":"campaign_cap","group_by":"tenant,campaign","metric":"messages","window_seconds":"30","limit":"2"}
]
}{
"decisions": [
{"id":"m1","status":"ADMITTED","violations":[]},
{"id":"m2","status":"ADMITTED","violations":[]},
{"id":"m3","status":"REJECTED","violations":[
{"rule":"campaign_cap","projected":3,"limit":2},
{"rule":"tenant_bytes","projected":1600,"limit":1500}
]},
{"id":"m4","status":"ADMITTED","violations":[]},
{"id":"m5","status":"ADMITTED","violations":[]}
],
"admitted_totals":{"messages":4,"bytes":2200}
}m2, tenant usage is 700 + 600 = 1300 bytes and campaign C has 2 messages. m3 projects 1300 + 300 = 1600 bytes and 3 campaign messages, so both extra rules fire and neither budget changes. m4 belongs to campaign D and raises tenant usage to exactly 1300 + 200 = 1500. At time 60, m1 is excluded by the open left boundary; m5 projects 600 + 200 + 700 = 1500 tenant bytes. Campaign C has no prior admitted message in (30, 60], so its projected count is 1. Batch totals are 4 messages and 700 + 600 + 200 + 700 = 2200 bytes.Example 3:
{
"messages": [
{"id":"m1","timestamp":"0","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"500"},
{"id":"m2","timestamp":"1","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"500"},
{"id":"m3","timestamp":"2","tenant":"T","sender":"a","recipient":"y","campaign":"D","bytes":"400"},
{"id":"m4","timestamp":"3","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"200"},
{"id":"m5","timestamp":"60","tenant":"T","sender":"a","recipient":"x","campaign":"C","bytes":"600"}
],
"extra_rules": [
{"id":"tenant_bytes","group_by":"tenant","metric":"bytes","window_seconds":"60","limit":"1500"},
{"id":"campaign_cap","group_by":"tenant,campaign","metric":"messages","window_seconds":"30","limit":"2"}
]
}{
"decisions": [
{"id":"m1","status":"ADMITTED","violations":[]},
{"id":"m2","status":"ADMITTED","violations":[]},
{"id":"m3","status":"ADMITTED","violations":[]},
{"id":"m4","status":"REJECTED","violations":[
{"rule":"campaign_cap","projected":3,"limit":2},
{"rule":"recipient_rate","projected":3,"limit":2},
{"rule":"sender_rate","projected":4,"limit":3},
{"rule":"tenant_bytes","projected":1600,"limit":1500}
]},
{"id":"m5","status":"ADMITTED","violations":[]}
],
"admitted_totals":{"messages":4,"bytes":2000}
}m4, the tenant has 500 + 500 + 400 = 1400 admitted bytes, sender a has 3 admitted messages, recipient x has 2, and campaign C has 2. Therefore m4 simultaneously projects 1600 bytes, 4 sender messages, 3 recipient messages, and 3 campaign messages. At time 60, m1 expires from the 60-second windows and both earlier campaign C messages have expired from its 30-second window. m5 projects 500 + 400 + 600 = 1500 tenant bytes, 3 sender messages, 2 recipient messages, and 1 campaign message, so it is admitted. Batch totals are 4 messages and 500 + 500 + 400 + 600 = 2000 bytes.Notes:
serialize and deserialize that convert a binary tree into a single string representation and back again. The representation must be unique and should correctly reconstruct the original tree structure. You can use any traversal method. def serialize(root: Optional[TreeNode]) -> str: def deserialize(data: str) -> Optional[TreeNode]: root = [1,2,3,null,null,4,5] "1,2,3,null,null,4,5" root = [1] "1,null" 0 and 10^4 nodes. [-1000, 1000]. start to node end.Example 1:edges = [[0, 1], [1, 2], [2, 3]], start = 0, end = 3[0, 1, 2, 3]0 to node 3 is 0 -> 1 -> 2 -> 3.Example 2:edges = [[0, 1], [1, 2], [0, 2], [2, 3]], start = 0, end = 3[0, 2, 3]Constraints:1 <= edges.length <= 10^4s, find the length of the longest substring containing at most two distinct characters.Example 1:s = "eceba"33.Example 2:s = "ccaabbb"55.Constraints:1 <= s.length <= 10^5s consists of English letters, digits, symbols, and spaces.LRUCache(int capacity): Initializes the cache with a positive size capacity.int get(int key): Returns the value of the key if the key exists, otherwise returns -1.void put(int key, int value): Update the value of the key if present, or add the key-value pair if not existing. When the cache reaches its capacity, it should invalidate the least recently used item before inserting a new item.LRUCache(2); cache.put(1, 1); cache.put(2, 2); cache.get(1); cache.put(3, 3); cache.get(2); cache.put(4, 4); cache.get(1); cache.get(3); cache.get(4);1; -1; 3; 4Constraints:capacity is always positive and will not exceed 1000get and put will always be called with valid keys.Sign up for free to access walkthroughs, AI-generated questions, and more.
Get Started Free