OpenAI interview questions

Showing 271–300 of 342 results

• Implement in-memory database insert and delete operationsHard

  This question evaluates understanding of data structures and algorithmic complexity in the context of designing a key-value in-memory database, and it falls under the Coding & Algorithms domain for a Machine Learning Engineer role while focusing on practical implementation skills.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Implement malloc and free over Fixed Memory, Then Make Both LogarithmicHard

  Implement malloc and free for a fixed range of memory in Python, first with a simple list of blocks and then with logarithmic-time operations backed by a third-party sorted container. It tests block splitting and merging, choosing ordered indexes for allocation and neighbor lookup, and keeping parallel structures consistent.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement node messaging and path discoveryMedium

  This question evaluates skills in distributed systems and algorithms, including reliable message-passing between adjacent nodes, graph traversal and path discovery, fault-tolerant protocol design, and message/time complexity analysis.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement persistent key-value storeMedium

  This question evaluates competency in implementing an in-memory key-value store with persistence, covering concepts such as serialization, durability, data structure management, and basic I/O handling.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement type AST and infer genericsHard

  This problem tests your ability to design a recursive data structure for an abstract syntax tree and implement a unification-based type inference engine for a simple functional language.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement vectorized NumPy ops and explain broadcastingMedium

  This question evaluates proficiency in vectorized numerical computing with NumPy, understanding of broadcasting semantics, and awareness of numerical stability and algorithmic time/space complexity when manipulating high-dimensional arrays.

  OpenAIMachine Learning EngineerData Manipulation (SQL/Python)Onsite
• Improve Training With Noisy AnnotatorsHard

  This question evaluates a candidate's ability to handle label noise by estimating annotator reliability and applying data-cleaning, relabeling, or reweighting methods while measuring model performance and understanding classification metrics.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Improve classifier with noisy multi-annotator labelsHard

  This question evaluates a candidate's ability to analyze noisy multi-annotator labels, design label-aggregation and dataset-splitting strategies, and choose modeling and evaluation approaches for binary text classification.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• In-Memory Key-Value Store with Crash Recovery from a Log and Concurrent AccessHard

  Implement an in-memory key-value store, make it recover from a log file after a crash, including a half-written final record, and make it correct and fast under many concurrent threads. It tests write-ahead logging, crash consistency, compaction, and lock design with group commit.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Indexed Vector as a Linked List with Checkpoints Every k NodesHard

  Implement an indexed dynamic sequence of strings, in the sense of an array list, that supports inserting at a position and reading by position. Starting from a plain singly linked list, build a linked list with a checkpoint every k nodes so reads cost O(k), and keep the checkpoints correct as insertions shift positions.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Infection Spread Simulation with Death ThresholdMedium

  Implement a cellular automaton simulating epidemic spread on a 2D grid with simultaneous infection and mortality transitions until convergence.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Infer Generic Return TypesMedium

  Implement a toy type-inference engine that unifies generic parameter types with concrete argument types and substitutes resolved type variables to determine the return type.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Key-Value Store Persistence: Length-Prefixed Bytes, Size-Capped Chunks, Thread SafetyHard

  A three-part key-value store exercise: serialize keys, values and their lengths into bytes and persist them on shutdown, split the saved data into chunks of a given maximum size, and discuss making the existing code safe for multithreaded use. It tests byte-level encoding, correct restore and concurrency reasoning.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Lab Robot Job Dispatcher with Backoff, Quarantine and PrereqsHard

  Implement an in-memory job dispatcher where failed jobs wait out a per-job backoff, keep their original queue position, and get quarantined after repeated failures, then add prerequisite jobs with cascading quarantine. Tests state modeling, dual-heap scheduling, and online topological ordering.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Lead Through Technical Difficulty and Project ConflictHard

  This question evaluates your ability to provide engineering leadership through severe technical uncertainty, resolve architectural or project disagreements constructively, and deliver measurable impact under high expectations.

  OpenAISoftware EngineerBehavioral & LeadershipHR Screen
• Lease-Based Job Queue for Flaky Render WorkersMedium

  Build an in-process job queue that hands out time-limited leases. A job is never lost when a worker crashes, hangs or fails, and jobs that always fail are dead-lettered after a retry limit. Tests state machines, fencing tokens, thread safety and clock-injected tests.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Leftmost-Fit Memory Allocator: Allocate Consecutive Units and Free by OwnerHard

  Simulate a memory allocator over n units: each allocation takes the leftmost run of consecutive free units for an owner, and each free releases all of that owner's units. Return the result of every operation. It tests interval bookkeeping and logarithmic-time search for free runs at up to 100,000 operations.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Leftmost-Fit Theater Row Booking With Bulk Cancellation by GroupHard

  Simulate booking a single theater row of n seats, where each booking takes the leftmost block of consecutive free seats for a group and a cancellation releases every seat that group currently holds anywhere in the row. Tests augmented-interval bookkeeping and logarithmic-time search for the best free run.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Maintain Entropy for a Streaming DistributionMedium

  Maintain empirical Shannon entropy after every categorical observation without rescanning all categories. The discussion should cover arbitrary identifiers, first-item behavior, exact counts, floating-point drift, concurrency, deletions, sliding windows, and merging summaries from separate stream partitions.

  OpenAIMachine Learning EngineerStatistics & MathOnsite
• Manage GPU Credits with ExpirationMedium

  This question evaluates data-structure design and algorithmic reasoning for time-based resource accounting, including handling expiring credits and out-of-order operations while maintaining efficient (logarithmic) performance constraints.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Measure free-month promotion impactHard

  This question tests the ability to design an experiment for a subscription product, focusing on causal inference, handling right-censoring in cohort data, and calculating the Return on Investment (ROI) for a promotional offer.

  OpenAIData ScientistAnalytics & ExperimentationTechnical Screen
• Merge overlapping intervalsMedium

  This question evaluates algorithmic problem-solving skills focused on interval manipulation, sorting and merging logic, and time/space complexity analysis within the Coding & Algorithms domain, emphasizing practical application.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Microorganism Eating Simulation: Largest Survivor After Left-to-Right RoundsHard

  Simulate a row of microorganisms in which each one may eat a strictly smaller neighbor from a different family, with rounds resolved from left to right, and report the family and size of the largest survivor at equilibrium. It tests precise rule-following, list mutation during iteration, and careful per-round bookkeeping.

  OpenAISoftware EngineerCoding & AlgorithmsOnline Assessment
• Minimize deaths in spreading plant infectionMedium

  This problem tests your ability to simulate a state-based grid propagation and optimize intervention timing using either greedy or dynamic programming approaches.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Model Infection, Immunity, Delayed Death, and Burn Interventions on a GridMedium

  Design and implement a discrete grid simulation modeling a five-stage disease progression with state countdowns, immunity, delayed mortality, and external burn interventions.

  OpenAIMachine Learning EngineerSoftware Engineering FundamentalsTechnical Screen
• Model particle hits on a screenHard

  This question evaluates geometric reasoning and probability theory skills, specifically transformation of random variables and derivation of CDF/PDF from angular sampling, together with practical competence in Monte Carlo simulation and interpretation of numerical and visualization artifacts; domain: Software Engineering Fundamentals.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Monitor Devices Over an Unreliable NetworkMedium

  Design an edge-to-cloud device monitoring system that accurately tracks device health and liveness across flaky, high-latency networks without falsely reporting absolute state.

  OpenAISoftware EngineerSystem DesignOnsite
• Optimize C++ Performance with Provided ConcurrencyMedium

  This question evaluates a developer's skills in C++ performance engineering and concurrent systems, covering profiling, bottleneck identification (e.g., cache locality and lock contention), and code-level performance reasoning to improve throughput and latency.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Order Recipe Prep Steps Into the Smallest Valid SequenceMedium

  Return a deterministic, lexicographically smallest valid ordering of named prep steps with dependency constraints, correctly including steps with no prerequisites and steps unconnected to any dependency.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Order Tasks with Dependencies Using a Deterministic Topological SortMedium

  Tests deterministic topological sorting of a directed acyclic graph using Kahn's algorithm and a priority queue to guarantee lexicographical tie-breaking.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen