OpenAI interview questions

Showing 301–330 of 342 results

• Parse and build binary data in PythonMedium

  This question evaluates proficiency in binary data handling and serialization/deserialization in Python, including little-endian integer encoding, length-prefixed payloads, robust error handling for short reads and invalid lengths, and testability and performance considerations.

  OpenAISoftware EngineerData Manipulation (SQL/Python)Technical Screen
• Plant Infection Grid Simulation: Days to Stabilize, Immune Plants, Expiring ImmunityHard

  A progressive grid simulation: infection spreads daily between adjacent plants, and you compute how many days the garden takes to stabilize, then add permanently immune plants and immunity that expires after a countdown. It tests multi-source breadth-first search, Dijkstra-style waiting times and precise day counting.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Prevent Duplicate Request ProcessingHard

  This System Design question evaluates understanding of idempotency, request deduplication, client- and server-side reliability mechanisms, and concurrency control in distributed systems.

  OpenAISoftware EngineerSystem DesignHR Screen
• Print Shop Job Queue: Retries, a Poison Queue and Job PrerequisitesHard

  Implement an in-memory job queue for a print shop where workers reserve, complete, or fail jobs, failed jobs retry up to a limit before landing in a poison queue, and a second part adds job prerequisites with cascading failure.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Project Deep Dive: Proving Technical Depth and Cross-Team AlignmentMedium

  A behavioral project deep-dive question in which you present a past project while the interviewer asks how you aligned with other functional teams and with engineers on your own team, and repeatedly presses on where the technical depth lies. It tests structured storytelling, clear ownership, evidence-backed decisions and composure under challenge.

  OpenAISoftware EngineerBehavioral & LeadershipOnsite
• Reactive Budget Notebook With Live Formulas and Cycle RejectionMedium

  Build a small reactive calculator where named variables hold integers or formulas that reference other variables, values stay correct as inputs change, and any definition that would create a circular dependency is rejected. Tests graph modeling, cache invalidation, cycle detection, and writing tests live.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Reason About Binary Search with One-Call-Delayed FeedbackHard

  Implement and analyze binary search under a 1-step delayed-feedback protocol where each query response evaluates the previous guess.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Rebalance shard ranges under overlap limitMedium

  This problem tests interval manipulation and greedy optimization by requiring you to adjust a set of shard ranges so that no more than k ranges overlap at any integer point, while minimizing the number of boundaries moved.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Recruiter Screen: Current Work, What You Want Next, Level and Work AuthorizationMedium

  Prepare for a recruiter screen for a software engineering role that asks what you are working on now, what you want next along with your current level and promotion history, and your work authorization. Tests concise, concrete answers that give a recruiter what they need to move a candidate forward.

  OpenAISoftware EngineerBehavioral & LeadershipHR Screen
• Refactor a Chatbot into Clean Object-Oriented ComponentsMedium

  Tests object-oriented design and refactoring skills by decoupling a monolithic chatbot script into modular, testable, and extensible components adhering to SOLID principles.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Refactor a chat message processing functionHard

  This problem tests your ability to refactor procedural, error-prone code into a robust, extensible pipeline for parsing and managing chat message state.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Repair a Broken Tiny Language Model, Then Make Decoding IncrementalHard

  Find four planted bugs in a compact PyTorch decoder-only language model (some produce NaNs, some silently ruin learning), then add key/value caching so generation processes one new token per step.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Resolve Short-Link Redirect Chains That May LoopHard

  Follow single-target redirects from a start code and return the final code, or the last code before the walk would revisit one. Then answer many starts in linear total time. Tests visited-set bookkeeping and functional-graph structure.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Return the Lexicographically Smallest Topological OrderMedium

  Implement a deterministic topological sort using a min-heap to return the lexicographically smallest ordering of a directed graph, or detect cycles and return an empty list.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Rotate Couriers Daily at Minimum Total CostHard

  Choose one courier company per day so that no company works two days in a row and the total price is minimal, then return the schedule. Tests DP over a small state, path reconstruction, and the best/second-best trick for k options.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Schedule Incremental Labeling TasksHard

  This problem tests the ability to design an incremental task scheduler that balances workload across a pool of annotators while maintaining fairness and deterministic state transitions.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Search Monster Battle StrategiesHard

  Design a search algorithm using state-space exploration to find the minimum number of turns required to defeat a boss given transient health, scripted boss attacks, and a single-use revive.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Select high-quality math documents from crawlsHard

  This question assesses the ability to design a scalable pipeline that ingests, cleans, extracts, and filters high-quality mathematical content from diverse, noisy web-crawled sources.

  OpenAIMachine Learning EngineerML System DesignOnsite
• Serialize and Restore an In-Memory Key-Value StoreMedium

  Design and implement a deterministic binary serializer and strict deserializer for a string key-value store, ensuring robust input validation against corruption, truncation, duplicate keys, and trailing data.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Simulate Infection Spread on a GridHard

  Implement a discrete-time cellular automaton simulating epidemic spread on a 2D grid with multi-day infection states, immunity waning, and mortality rules.

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen
• Simulate Infection Spread with Immunity and RecoveryMedium

  Implement a cellular automaton simulation modeling disease spread on a 2D grid with discrete cell states and timed recovery.

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen
• Simulate Plant Infection With Controlled BurningHard

  This question evaluates a candidate's ability to implement discrete-time grid simulations with delayed state transitions, reason about simultaneous updates and neighborhood effects, and perform a limited combinatorial optimization (choosing one row or column) to minimize a global outcome.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Simulate Turn-Based Monster BattlesMedium

  This problem tests your ability to design a stateful simulation engine that handles turn-based mechanics, complex status modifiers, and dynamic combat interactions.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Simulate a Turn-Based Two-Player GameEasy

  This problem tests your ability to design a robust state management system and implement validation logic for a rule-based game.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Sliding-Window Chat Analytics: Recent Counts, Live Sessions, Out-of-Order EventsMedium

  A three-part coding exercise: build an in-memory chat analytics service that counts each chat's interactions in a closed 15-minute sliding window, tracks each user's live sessions from touch and close events, and stays correct when events arrive out of order. It tests bounded-memory eviction, efficient updates and queries, and exact window and ordering semantics.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Sliding-Window Forklift Telemetry: Pings, Shifts, Late EventsMedium

  Build an in-memory telemetry service that counts a forklift's recent pings in a 15-minute window, tracks which forklifts are currently on an active shift, and stays correct when pings arrive late and out of order. Tests bounded-memory eviction and exact window semantics.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Social Graph with Follow/Unfollow, Snapshots, History Queries and RecommendationsMedium

  A software engineer phone-screen coding problem: build an in-memory social graph that supports follow and unfollow, point-in-time snapshots, queries of who followed whom as of an earlier snapshot, and recommendations of users to follow. It tests data-structure choice, versioned history, and deterministic ranking.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Spreading Contagion on a GridMedium

  Tests modeling multi-source breadth-first search (BFS) on a 2D grid to compute simultaneous state propagation across discrete time steps.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Spreadsheet engine with setCell/getCell, cell references, and cycle detectionMedium

  Build a small spreadsheet engine with setCell and getCell, where formulas reference other cells and a write that would create a circular dependency must be detected. The exercise also asks for live unit tests, probing data modeling, dependency graphs, cache invalidation and test design.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Streaming Entropy with Numerical StabilityHard

  Implement an online, numerically stable algorithm to compute Shannon entropy over an unbounded stream of categorical tokens with O(1) updates.

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen