Retool Software Engineer Interview Questions

## Round 1 - Coding ## Problem Given a source string and a query, return the source string with matching characters wrapped in highlight markers. Match the query characters in order (subsequence match, not substring). Return the highlighted string and a match score (bonus for consecutive matches). ```python def highlight(source: str, query: str, open_tag: str = "[", close_tag: str = "]") -> tuple[str, int]: # returns (highlighted_string, score) # score = len(query) base + bonus for each run of consecutive matches # returns ("", -1) if no subsequence match ... ``` ## Example ``` highlight("Python", "Pto") # Match P(0), t(2), o(4) as subsequence # -> ("[P]y[t]h[o]n", 3) highlight("Python", "Pyt") # Match P(0),y(1),t(2) -> consecutive run of 3 -> bonus # -> ("[Pyt]hon", 6) # score 3 base + 3 consecutive bonus highlight("Python", "xyz") # -> ("", -1) # no match ``` ## Follow-ups 1. How does your scoring affect the ranking of multiple candidate strings for the same query? 2. How do you make matching case-insensitive while preserving the original casing in output? 3. How would you extend this to a fuzzy match that allows one character substitution? 4. Given a list of 10,000 filenames, how do you efficiently rank them by match score for a query?

## Round 1 - Coding ## Problem Given a Markov chain as a transition matrix (rows sum to 1), simulate `N` steps from a given starting state and estimate the steady-state distribution. Also implement exact power iteration to compute the true stationary distribution. ```python import random def simulate_chain(transition: list[list[float]], start_state: int, steps: int) -> list[float]: # returns empirical state visit frequencies ... def stationary_distribution(transition: list[list[float]], tol: float = 1e-8) -> list[float]: # power iteration until convergence ... ``` ## Example ``` T = [ [0.9, 0.1], [0.5, 0.5], ] # Exact stationary: solve pi*T = pi; pi[0]+pi[1]=1 # -> pi = [0.833..., 0.166...] stationary_distribution(T) -> [0.8333, 0.1667] # approx simulate_chain(T, start_state=0, steps=10000) # -> [~0.83, ~0.17] (empirical, will vary) ``` ## Follow-ups 1. How do you detect whether a Markov chain has a unique stationary distribution (is it ergodic/irreducible/aperiodic)? 2. How many steps does simulation typically need to converge? What influences the mixing time? 3. How would you extend this to a continuous-time Markov chain using a rate matrix (generator matrix)? 4. How would you visualize the chain as a directed graph with edge weights?

## Round 1 - Coding / SQL ## Problem Implement an in-memory SQL execution engine that parses and executes simple SQL queries over Python dictionaries acting as tables. Support `SELECT`, `FROM`, `WHERE`, and `INNER JOIN`. ```python class SQLEngine: def __init__(self): self.tables: dict[str, list[dict]] = {} def create_table(self, name: str, rows: list[dict]) -> None: ... def execute(self, query: str) -> list[dict]: # parses and runs the SQL query string ... ``` ## Example ``` engine = SQLEngine() engine.create_table("users", [{"id":1,"name":"Alice"},{"id":2,"name":"Bob"}]) engine.create_table("orders", [{"user_id":1,"item":"Book"},{"user_id":1,"item":"Pen"},{"user_id":2,"item":"Bag"}]) engine.execute("SELECT name, item FROM users JOIN orders ON users.id = orders.user_id WHERE name = 'Alice'") # -> [{"name":"Alice","item":"Book"},{"name":"Alice","item":"Pen"}] engine.execute("SELECT * FROM users WHERE id > 1") # -> [{"id":2,"name":"Bob"}] ``` ## Follow-ups 1. How do you tokenize and parse the SQL string without an external parser library? 2. How would you add support for `GROUP BY` and aggregation functions like `COUNT` and `SUM`? 3. How do you handle column name ambiguity when both tables have a column with the same name? 4. What optimizations would you apply (e.g., predicate pushdown, hash join) as table sizes grow?

## Problem Find the best time to buy and sell stock(s) to maximize profit, possibly with transaction limits or cooldown constraints. ## Likely LeetCode equivalent LeetCode 121 - Best Time to Buy and Sell Stock. ## Tags arrays,dynamic_programming,greedy,swe

## Round 1 - Coding ## Problem Implement the core logic of Wordle. The player has 6 attempts to guess a 5-letter secret word. After each guess, each letter is marked: correct position (green/`G`), wrong position (yellow/`Y`), or not in word (gray/`X`). ```python class Wordle: def __init__(self, secret: str): ... def guess(self, word: str) -> str: # returns 5-char string: "G", "Y", or "X" per letter # raises ValueError if word is not 5 letters # raises GameOverError if already won or out of guesses ... def is_won(self) -> bool: ... def attempts_left(self) -> int: ... ``` ## Example ``` game = Wordle("crane") game.guess("slate") -> "XXYXY" # s=X,l=X,a=Y,t=X,e=Y game.guess("trace") -> "YGGGY" # t=Y,r=G,a=G,c=G,e=Y game.guess("crane") -> "GGGGG" game.is_won() -> True game.attempts_left() -> 3 ``` ## Follow-ups 1. How do you handle duplicate letters correctly — e.g., secret is `"crane"` and guess is `"erred"`? Walk through the marking logic. 2. How would you build a solver that narrows the candidate word list using feedback from each guess? 3. How do you validate that a guess is a real English word (not just any 5-letter string)? 4. How would you extend this to a multiplayer version where all players guess the same daily word?