Snowflake Software Engineer Phone Screen Questions

Question 1: 1004 Question 2: 1650 The first question is in the LeetCode tags, but I haven't practiced it before. I thought of using sliding windows, but I was too nervous during the interview and made

**EDIT:** I got the job. I have put a detailed comment in this particular post. So, please go through it properly before DM-ing me. Hey folks! I’ve got upcoming Software Engineer interviews

## Problem Simulate or solve a board game problem, likely finding optimal moves or win conditions using dynamic programming or BFS. ## Likely LeetCode equivalent No direct match. ## Tags coding, dynamic_programming, simulation

## Problem You are given a list of roads between cities, each with a travel time. Find the minimum time to travel from a source city to a destination city. If no path exists, return -1. ```python from typing import List, Dict def shortest_path( n: int, roads: List[List[int]], source: int, destination: int ) -> int: # n: number of cities (0-indexed) # roads: [[city_a, city_b, travel_time], ...] (undirected) # return: minimum travel time, or -1 if unreachable pass ``` **Example:** ``` n = 4 roads = [[0,1,4],[0,2,1],[2,1,2],[1,3,1]] source = 0, destination = 3 Shortest: 0->2->1->3, cost = 1+2+1 = 4 Output: 4 ``` ## Approach Dijkstra's algorithm with a min-heap. Time: O((V + E) log V). ## Follow-ups 1. What changes if roads are directed (one-way)? 2. How would you handle negative edge weights? What algorithm applies? 3. If you need to find the shortest path that passes through a required intermediate city, how do you modify the approach? 4. How would you return the actual path (list of cities) in addition to the cost?

## Problem You have a log of HTTP requests, each with a timestamp (seconds) and a status: `"success"` or `"dropped"`. Find all contiguous time windows of length `W` seconds where the drop rate exceeds threshold `T` (0.0 to 1.0). Return the start times (inclusive) of all such windows. ```python from typing import List, Tuple def high_drop_windows( requests: List[Tuple[int, str]], W: int, T: float ) -> List[int]: # requests: [(timestamp, status), ...] sorted by timestamp # W: window size in seconds # T: drop rate threshold (exclusive) # return: sorted list of window start times pass ``` **Example:** ``` requests = [(0,"dropped"),(1,"dropped"),(2,"success"),(5,"dropped"),(6,"dropped")] W=3, T=0.5 Window [0,3): 2 dropped / 3 total = 0.67 > 0.5 -> include start=0 Window [4,7): 2 dropped / 2 total = 1.0 > 0.5 -> include start=4 Output: [0, 4] ``` ## Follow-ups 1. What if requests are NOT sorted by timestamp — what preprocessing is needed? 2. How would you adapt this to a live streaming data source using a sliding window? 3. How do you handle windows that contain zero requests (divide-by-zero case)? 4. In an alerting system, how would you avoid duplicate alerts for overlapping windows?

## Problem Flatten a hierarchical org chart (tree) into a list while preserving order (e.g., pre-order or level-order traversal). ## Likely LeetCode equivalent No direct match. ## Tags binary_tree, traversal, coding

## Problem You have a permission system with roles. Each role can inherit from other roles. Each role also has explicit ALLOW or DENY rules for named permissions. DENY always overrides ALLOW. Given a user's assigned roles, compute their effective set of allowed permissions. Resolution order: 1. Collect all permissions from the user's roles and all ancestor roles (BFS/DFS). 2. If any role in the chain DENY's a permission, it is denied globally. 3. Otherwise, if any role ALLOW's it, it is allowed. ```python from typing import List, Dict, Set def resolve_permissions( roles: Dict[str, dict], user_roles: List[str] ) -> Set[str]: # roles: {role_name: {"inherits": [str], "allow": [str], "deny": [str]}} # return: set of effective allowed permissions pass ``` **Example:** ``` roles = { "admin": {"inherits": [], "allow": ["read","write","delete"], "deny": []}, "auditor": {"inherits": ["admin"], "allow": [], "deny": ["delete"]}, } user_roles = ["auditor"] Output: {"read", "write"} # delete is denied by auditor ``` ## Follow-ups 1. How do you detect and handle cycles in the role inheritance graph? 2. What if DENY in a child role should NOT override ALLOW in a parent — how would resolution logic change? 3. How would you cache resolved permission sets efficiently as the role graph changes? 4. How does this model compare to RBAC vs. ABAC systems?

## Problem Given a binary tree and a root-to-leaf path specified as a list of node values, remove all nodes on that path from the tree. If removing a node would leave its parent with no children and that parent is not on another path, remove it too (cascading deletion upward stops when a node has a surviving child). Return the root of the modified tree. ```python class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def remove_path(root: TreeNode, path: list) -> TreeNode: pass ``` **Example:** ``` Tree: 1 / \ 2 3 / \ 4 5 path = [1, 2, 4] After removal: 1 / \ 2 3 \ 5 # Node 4 removed; node 2 kept because it still has child 5. ``` ## Follow-ups 1. What if the path does not reach a leaf — should removal still happen? 2. How do you handle a path that doesn't exist in the tree? 3. What if you need to remove multiple paths simultaneously — does order of removal matter? 4. How does this problem change for an N-ary tree instead of a binary tree?

## Problem You are given a list of service error events, each with a `service`, `error_code`, and `timestamp`. Identify all `(service, error_code)` pairs that appear more than `threshold` times within any rolling 60-second window. Return results as a list of `(service, error_code, window_start, count)` tuples, sorted by `window_start`. ```python from typing import List, Tuple def find_error_bursts( events: List[Tuple[str, str, int]], threshold: int ) -> List[Tuple[str, str, int, int]]: # events: [(service, error_code, timestamp_sec), ...] sorted by timestamp # return: [(service, error_code, window_start, count), ...] pass ``` **Example:** ``` events = [ ("auth", "500", 0), ("auth", "500", 10), ("auth", "500", 50), ("auth", "500", 70), ("db", "timeout", 5) ] threshold = 2 Window [0,60): auth/500 appears 3 times > 2 -> include Output: [("auth", "500", 0, 3)] ``` ## Follow-ups 1. How do you adapt this to a live stream where events arrive with up to 30 seconds of out-of-order delay? 2. What alerting de-duplication strategy would you apply to avoid flooding on-call with repeated alerts? 3. How would you store and query this data efficiently in a time-series database? 4. How would you distinguish transient bursts from sustained elevated error rates?

## Problem Transform a tree by replacing each node's value with the sum of its subtree. Involves a post-order DFS traversal. ## Likely LeetCode equivalent No direct match. ## Tags binary_tree, dfs, coding

## Problem Execute tasks respecting dependencies or ordering constraints, likely using topological sort to determine valid execution order. ## Likely LeetCode equivalent No direct match. ## Tags sorting, graph, coding

## Problem Design a `WikiBot` class that ingests a set of (entity, relation, value) triples and answers natural-language-style queries of the form `"What is the <relation> of <entity>?"`. Return all matching values, or `"Unknown"` if no match exists. ```python class WikiBot: def __init__(self): pass def ingest(self, entity: str, relation: str, value: str) -> None: pass def query(self, entity: str, relation: str) -> list: # return list of values, or ["Unknown"] pass ``` **Example:** ``` bot = WikiBot() bot.ingest("Paris", "capital_of", "France") bot.ingest("Paris", "population", "2.1M") bot.ingest("Paris", "population", "2.16M") # updated estimate bot.query("Paris", "capital_of") -> ["France"] bot.query("Paris", "population") -> ["2.1M", "2.16M"] bot.query("Lyon", "capital_of") -> ["Unknown"] ``` ## Follow-ups 1. How would you support reverse lookups — "What entities have relation X with value Y"? 2. How would you handle confidence scores on triples and return only results above a threshold? 3. If the knowledge graph grows to 100M triples, what storage and indexing strategy would you use? 4. How would you detect and resolve contradictory triples for the same (entity, relation) pair?