Sigma Computing Software Engineer Interview Questions

The follow-up round involves reviewing your code and adding a few follow-ups, such as how to support addition, subtraction, multiplication, and division. It also discusses potential changes. For the s

Design a spreadsheet with: Unlimited rows, limited columns Columns have string names (like "A", "B", "Sales") All cells store integers (default: 0) Support these 3 operations: Set(row, column, value)

Sigma Computing, a B2B SaaS analytics startup, utilizes a practical, collaborative first-round interview rather than standard algorithmic puzzles. The challenge involves implementing a backend for a s

**Context** The interview focuses on a `Spreadsheet` class initialized with specific dimensions ($M$ rows, $N$ columns). The class provides the following pre-built methods: * `set_cell(row, col, value

**Context** This interview involved a coding challenge focused on a spreadsheet class implementation. It served as the second round of the process, thematically linked to the first round but with incr

## Problem Implement a spreadsheet-style cell table with formula evaluation and dependency resolution between cells. ## Likely LeetCode equivalent No direct LC match; topological sort / graph problem. ## Tags matrix, graph, topological-sort

## Problem Implement a JSON parser from scratch, handling nested objects, arrays, strings, numbers, booleans, and null. ## Likely LeetCode equivalent No direct LC match; recursive descent parsing problem. ## Tags recursion, strings, parsing

## Problem Given the following schema: ```sql orders(id INT, customer_id INT, status VARCHAR, created_at TIMESTAMP, total DECIMAL) order_items(order_id INT, product_id INT, quantity INT, unit_price DECIMAL) products(id INT, name VARCHAR, category VARCHAR) customers(id INT, name VARCHAR, country VARCHAR) ``` Write SQL for: **Q1:** Monthly revenue for the past 12 months, broken down by product category. **Q2:** Customers who placed orders in every month of the last 6 months (consistently active). **Q3:** For each customer, their most recent order total and whether it is higher or lower than their average order total. **Example output for Q3:** ``` customer_id | latest_order | avg_order | vs_avg ------------+--------------+-----------+-------- 1001 | 250.00 | 180.00 | above 1002 | 45.00 | 90.00 | below ``` ## Follow-ups 1. How would you optimize Q2 for a table with 50M order rows? 2. Rewrite Q1 using a CTE vs a subquery - which is more readable and why? 3. How would you handle timezone differences in `created_at` for monthly bucketing? 4. Add a column for 30-day rolling revenue to Q1.

## Problem Design a role-based access control (RBAC) system. Users are assigned roles; roles have permissions; permissions are `(resource, action)` pairs. Implement: - `add_role(role_name)` - `grant_permission(role_name, resource, action)` - `assign_role(user_id, role_name)` - `can(user_id, resource, action) -> bool` - `revoke_role(user_id, role_name)` Roles can inherit from other roles. ```python class PermissionSystem: def add_role(self, role: str, inherits: str = None): ... def grant_permission(self, role: str, resource: str, action: str): ... def assign_role(self, user_id: str, role: str): ... def can(self, user_id: str, resource: str, action: str) -> bool: ... def revoke_role(self, user_id: str, role: str): ... ``` **Example:** ``` sys.add_role("viewer") sys.add_role("editor", inherits="viewer") sys.grant_permission("viewer", "doc", "read") sys.grant_permission("editor", "doc", "write") sys.assign_role("u1", "editor") sys.can("u1", "doc", "read") -> True # inherited from viewer sys.can("u1", "doc", "delete") -> False ``` ## Follow-ups 1. How do you handle circular inheritance (role A inherits B inherits A)? 2. How would you scale `can()` checks to millions of requests per second? 3. Add resource wildcards (e.g., permission on `"doc:*"` covers all doc resources). 4. How would you audit who has access to a given resource?

## Problem Build or simulate a pivot table that aggregates and transforms tabular data similar to spreadsheet pivot functionality. ## Likely LeetCode equivalent No direct LC equivalent. ## Tags design, hash_table, arrays

## Problem You are given a list of tokens representing a mathematical expression in prefix notation. Build the expression tree and evaluate it. Tokens are either operators (`+`, `-`, `*`, `/`) or integer literals. ```python def evaluate_token_tree(tokens: List[str]) -> float: ... ``` **Example:** ``` Input: ["*", "+", "3", "4", "2"] Expression: (* (+ 3 4) 2) = (3+4)*2 = 14 Output: 14 Input: ["+", "*", "2", "3", "/", "8", "4"] Expression: (+ (* 2 3) (/ 8 4)) = 6 + 2 = 8 Output: 8 ``` ## Approach Use a recursive descent parser with a pointer into the token list. Each call to `parse()` consumes one operator and recursively parses its two operands. ```python def parse(tokens, idx): token = tokens[idx] if token not in "+-*/": return float(token), idx + 1 left, idx = parse(tokens, idx + 1) right, idx = parse(tokens, idx) return apply(token, left, right), idx ``` ## Follow-ups 1. Extend to handle unary operators (e.g., negation). 2. How would you convert an infix expression to prefix notation first? 3. Add support for variables (e.g., `x`, `y`) with a substitution map. 4. How does this change if tokens are streamed one at a time?