OpenAI: Software Engineer

from collections import deque
def days_to_infect(grid):          # 1 = infected, 0 = healthy, -1 = empty
    R, C = len(grid), len(grid[0]); q = deque(); healthy = 0
    for r in range(R):
        for c in range(C):
            if grid[r][c] == 1: q.append((r, c, 0))
            elif grid[r][c] == 0: healthy += 1
    days = 0
    while q:
        r, c, d = q.popleft(); days = max(days, d)
        for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
            nr, nc = r + dr, c + dc
            if 0 <= nr < R and 0 <= nc < C and grid[nr][nc] == 0:
                grid[nr][nc] = 1; healthy -= 1; q.append((nr, nc, d + 1))
    return days if healthy == 0 else -1

• Multi-source BFS, O(R·C).
• Typical follow-up parts: recovery after k days, immunity, probabilistic infection, very large sparse grids (use a hash set), tracking the per-day count. Write modular code so each new part is a small change.

def length_of_longest(s):
    pos, start, best = {}, 0, 0
    for i, ch in enumerate(s):
        if pos.get(ch, -1) >= start: start = pos[ch] + 1
        pos[ch] = i; best = max(best, i - start + 1)
    return best

• A sliding window, O(n). Explain it before coding, then test edge cases ("", "aaaa", "abba").

• Requirements: channels and DMs, message ordering, presence, notifications, search, files; millions of concurrent connections.
• Architecture:
• Clients ↔ WebSocket gateway fleet (connection state in Redis).
• The message service writes to a partitioned store keyed by channel_id (Cassandra/Scylla, or sharded Postgres), with ordering by per-channel sequence IDs.
• Fan-out through a pub/sub layer (Kafka plus in-memory channel subscriptions) to the gateways holding channel members.
• Offline users: push notifications; unread counts per user per channel.
• Search: async indexing into Elasticsearch with ACL filtering.
• Scale and reliability: hot-channel handling (sharded fan-out), idempotent message IDs from clients, backpressure, multi-region with channel home regions.

• The front door: API gateway → auth and rate limiting per organisation and tier (token buckets on requests and tokens).
• Router: choose the model or deployment by capacity, region and priority; queue with fair scheduling.
• Inference servers: continuous batching, paged KV cache, prefix caching for shared system prompts, streaming via SSE.
• Reliability: autoscaling on GPU queue depth, failover across clusters, graceful degradation (shed low-priority traffic).
• Observability and billing: token metering, per-request traces, abuse and safety monitoring.

• Ownership: what you designed and decided, not the team.
• Technical depth: why this architecture? What broke at scale? How did you measure it?
• Trade-offs and mistakes: what you'd change now.
• Impact: users, latency, cost, reliability numbers.
• Prepare one project you can discuss for 45 minutes without running out of depth.

Answer (STAR):

• "We had to ship a streaming API in two weeks. I cut scope to the core path, wrote contract tests first, used a feature flag, and ran a 1% canary with automatic rollback on error-rate alerts. We launched on time with no incidents, then iterated on the deferred features."
• OpenAI values speed with safety, clear communication and mission alignment.