Faire Software Engineer Interview Questions

## Problem You are given a list of content items, each with a `type` ("article", "ad", "sponsored"), `source`, and `score`. Filter out items that are ads or sponsored, and also remove organic items with a score below a minimum threshold. Return the remaining items sorted by score descending. ```python from dataclasses import dataclass @dataclass class ContentItem: id: int type: str source: str score: float def filter_ads( items: list[ContentItem], min_score: float ) -> list[ContentItem]: pass ``` ``` Input: items = [ ContentItem(1, "article", "cnn", 0.9), ContentItem(2, "ad", "google", 0.95), ContentItem(3, "sponsored", "brand", 0.7), ContentItem(4, "article", "bbc", 0.3), ] min_score = 0.5 Output: [ContentItem(1, "article", "cnn", 0.9)] # item 2,3 removed (ad/sponsored), item 4 below threshold ``` ## Follow-ups 1. How would you extend the filter to use a blocklist of known ad sources? 2. If `type` is missing or null, what fallback heuristic would you apply? 3. How would you add a user-configurable filter pipeline where each rule is a pluggable strategy? 4. Extend to support "native ads" that look like articles — what signals would you use to detect them?

## Problem You are given a list of date strings in various formats. Normalize them all to `YYYY-MM-DD`. Supported input formats include: `MM/DD/YYYY`, `DD-MM-YYYY`, `Month DD, YYYY` (e.g., `"January 5, 2023"`), and ISO `YYYY-MM-DD`. Return `None` for unparseable strings. ```python def normalize_date(date_str: str) -> str | None: pass def batch_normalize(dates: list[str]) -> list[str | None]: pass ``` ``` Input: ["01/15/2023", "15-01-2023", "January 15, 2023", "2023-01-15", "bad input"] Output: ["2023-01-15", "2023-01-15", "2023-01-15", "2023-01-15", None] ``` ## Follow-ups 1. How do you distinguish `MM/DD/YYYY` from `DD/MM/YYYY` when the day is <= 12? 2. How would you handle two-digit years (e.g., `"01/15/23"`) — what century assumption is safe? 3. Extend to also normalize time zones: inputs may include `"Jan 15 2023 10:00 EST"`. 4. How would you make this function production-grade — what edge cases and locales must you test?

## Problem You have a list of user events `(user_id, event_name, timestamp)`. A conversion funnel is defined as an ordered list of event names. A user "completes" step `i` of the funnel if they fired event `i` after completing step `i-1` (events must occur in order but not necessarily consecutively). Compute the number of unique users who reached each step. ```python def funnel_count( events: list[tuple[int, str, int]], # (user_id, event, timestamp) funnel: list[str] ) -> list[int]: """Return list of user counts at each funnel step.""" pass ``` ``` Input: events = [(1,"view",1),(1,"click",2),(1,"purchase",3), (2,"view",1),(2,"click",4), (3,"view",2)] funnel = ["view", "click", "purchase"] Output: [3, 2, 1] # All 3 users reached step 1 (view) # Users 1,2 reached step 2 (click) # Only user 1 reached step 3 (purchase) ``` ## Follow-ups 1. How do you write this as a SQL query using self-joins or window functions? 2. If the funnel must be completed within a time window (e.g., 7 days), how does your logic change? 3. How would you compute conversion rates and visualize the drop-off percentages? 4. Extend to support optional funnel steps that are counted but do not block progression.

## Problem A haiku consists of three lines with syllable counts 5, 7, 5. You are given a sequence of words with known syllable counts. Find all contiguous subsequences of words that can be partitioned into three groups with syllable sums 5, 7, and 5 in order. ```python def find_haiku_substrings( words: list[tuple[str, int]] # (word, syllables) ) -> list[list[str]]: """Return list of word groups [line1_words, line2_words, line3_words].""" pass ``` ``` Input: words = [("old",1),("pond",1),("a",1),("frog",1),("jumps",1), ("in",1),("sound",1),("of",1),("water",2)] # We need 5,7,5=17 syllables total (all 9 words = 10 syllables, not enough) # Simplify: syllable counts vary. Output: [ # each found haiku as three lines [["old","pond",...], [...], [...]] ] ``` ## Follow-ups 1. How do you efficiently scan for valid 5-7-5 partitions using prefix sums? 2. What if syllable counts are uncertain and vary by pronunciation — how do you enumerate possibilities? 3. How would you extend this to detect other poetic forms (limerick: 8-8-5-5-8)? 4. If words can be reordered within each line, does the problem become NP-hard?

## Problem An SMS message can be at most 160 characters. If a message is longer, it must be split into parts, each suffixed with `" (X/N)"` where `X` is the part number and `N` is the total number of parts. The suffix counts toward the 160-character limit. Return the list of message segments. ```python def split_sms(message: str) -> list[str]: pass ``` ``` Input: message = "A" * 200 Output: two segments # With N=2, suffix " (1/2)" and " (2/2)" each 6 chars # Usable per part: 160-6=154 chars # Part1: 'A'*154 + ' (1/2)' [160 chars] # Part2: 'A'*46 + ' (2/2)' [52 chars] # Total content: 154+46=200 -> correct Input: message = "Hello" # <= 160 chars Output: ["Hello"] # no suffix needed ``` ## Follow-ups 1. The suffix length depends on `N`, which depends on the split — is there a circular dependency? How do you resolve it? 2. How would you split on word boundaries rather than arbitrary character positions? 3. Extend to handle unicode: some characters are 2 bytes in GSM encoding and count as 2 toward the 160-char limit. 4. What if the suffix format changes to `"[X of N]"` — how does your solution adapt?

## Problem Validate that HTML or XML tags are properly nested and closed using a stack. ## Likely LeetCode equivalent Similar to LC 20 Valid Parentheses. ## Tags coding, stack, parsing, onsite

## Problem Set entire rows and columns to zero if a cell in that row/column is zero. ## Likely LeetCode equivalent LeetCode 73 - Set Matrix Zeroes ## Tags coding, matrix, in_place, phone