OpenAI interview questions

Showing 241–270 of 342 results

• Implement NumPy neural-network layersMedium

  This question tests your ability to implement fundamental neural network components using NumPy, focusing on matrix operations, broadcasting, and numerical stability.

  OpenAIData ScientistMachine LearningOnsite
• Implement Prefix Products and Their Backward PassMedium

  Work through inclusive prefix products in separate-output, in-place, reverse-gradient, and parallel variants. Explain zeros, overflow, mutation and aliasing, constant temporary workspace, synchronization, floating-point effects, and the work/depth trade-offs of each part.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Implement Social Follow RecommendationsMedium

  This problem tests your ability to navigate a social graph to implement a recommendation system using set operations and frequency counting.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement Social Graph Snapshot QueriesMedium

  This problem tests your ability to design a query-optimized representation for a directed graph, specifically focusing on efficient retrieval of multi-hop relationships and neighbor-based ranking.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement Three Research Coding TasksMedium

  This problem tests fundamental understanding of numerical stability in probability, memory-efficient buffering, and greedy combinatorial optimization.

  OpenAISoftware EngineerCoding & AlgorithmsHR Screen
• Implement Time-Aware GPU Credit LedgerMedium

  Design an in-memory credit ledger that tracks GPU compute grants with expiration timestamps, consumes credits greedily by earliest expiration, and supports atomic deductions.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement a 1-Nearest-Neighbor Classifier with a Manhattan-Distance Follow-UpHard

  Implement a 1-nearest-neighbor classifier that labels each query point with the label of its closest training point under Euclidean distance, then extend it to Manhattan distance. Tests vectorized distance computation under memory limits, tie handling and how the choice of metric changes predictions.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Implement a Contiguous Memory Allocator with Primitive ListsHard

  Simulate best-fit allocation across a contiguous address range using only primitive lists and scalar state. Support splitting, exact-pointer frees, double-free rejection, deterministic tie-breaking, and coalescing adjacent free blocks across up to 10,000 operations.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement a Distributed Rate LimiterMedium

  Implement a distributed token bucket rate limiter backed by a key-value store with optimistic concurrency control (CAS), handling clock skew, concurrent updates, and token replenishment.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement a GPU credit ledger with expiring grants and out-of-order operationsMedium

  Implement a GPU credit ledger with grant, subtract and get-balance operations, where grants expire and spending draws from the soonest-expiring grant first. Operations can arrive out of timestamp order, and a follow-up asks how to avoid replaying the whole history from time zero on every query in production.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a GPU credit managerMedium

  This question evaluates understanding of concurrent resource management, advanced data structures for top-K and per-user queries, enforcement of caps and expirations, and algorithmic complexity guarantees while maintaining atomicity under concurrent operations.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement a Recoverable In-Memory Key-Value StoreMedium

  This problem tests your understanding of durability, logging, and data persistence in an in-memory system.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a Set with Readable SnapshotsHard

  Design and implement a versioned set data structure that supports membership modifications, instant snapshotting, and historical point-in-time queries efficiently.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Simple Memory AllocatorMedium

  This question evaluates low-level memory management and allocator design skills, including block header layout, free-list/data-structure choices, pointer arithmetic, fragmentation concepts, and analysis of time/space complexity.

  OpenAISoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a fault-tolerant work queue that never loses tasks when workers failMedium

  Implement an in-process work queue that never loses a task when the worker holding it crashes, stalls or reports an error. It tests task state tracking, detecting silent workers, rejecting late reports from workers that lost a task, bounded retries for tasks that always fail, thread safety, and deterministic tests built on an injected clock.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement a memory allocator with malloc/freeMedium

  This question evaluates understanding of memory allocator concepts including malloc/free semantics, contiguous allocation, fragmentation handling, coalescing of adjacent free blocks, pointer validation, and data-structure choices for efficient allocation.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement a minimal reverse-mode autograd engine on PyTorch tensorsHard

  Implement the core of a PyTorch-style autograd system: a tensor wrapper that records addition, multiplication, matrix multiplication, ReLU and sum, plus a backward method that fills in gradients for every input. Tests reverse-mode differentiation, correct ordering of the backward pass, gradient accumulation for tensors used more than once, and verification against PyTorch.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Implement a serializable key-value storeMedium

  This question evaluates competency in implementing robust serialization and in-memory data structures, covering binary format design, handling arbitrary bytes and Unicode, correctness across edge cases (empty state, large keys/values, overwrites, deletions), input validation and failure recovery, complexity analysis, and unit testing.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement an Extensible Chatbot AppMedium

  This question evaluates a candidate's ability to design extensible object-oriented systems, covering interface-based architecture, dependency injection, per-conversation state management, and decoupled dispatch logic.

  OpenAISoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Implement an IPv4 IteratorMedium

  This problem tests your ability to handle IPv4 address arithmetic, bitwise operations, and the implementation of a stateful iterator that supports bidirectional traversal and range generation from CIDR notation.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Implement an IPv4 Range IteratorMedium

  This problem tests your ability to manipulate 32-bit integers, understand bitwise operations, and implement a custom iterator for a contiguous range of IP addresses.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement an expiring GPU credits ledgerMedium

  This question evaluates understanding of time-based resource accounting, design of data structures for expiring balances, atomic update semantics for concurrent operations, and algorithmic time/space complexity within the Coding & Algorithms domain.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement an in-memory SQL-like tableHard

  This question evaluates implementation skills for an in-memory SQL-like table, focusing on data modeling with nested key-value structures, string handling, efficient lookups, and lexicographic sorting with tie-breaking.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Implement and Debug Backprop in NumPyMedium

  This question evaluates understanding of backpropagation and the chain rule, proficiency in vectorized NumPy implementation, numerical stability of softmax/cross-entropy, and competency in gradient checking and debugging of model gradients.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Implement delimiter-free string codecMedium

  This question evaluates a candidate's ability to design reversible string encodings that handle arbitrary characters and edge cases, testing competency in string manipulation, data serialization, and robustness.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement expiring credit ledgerMedium

  This question evaluates the ability to design efficient time-based data structures and algorithms for managing expiring credits with ordering and tie-breaking rules, testing competencies in event ordering, interval management, and retroactive update handling; it is in the Coding & Algorithms domain and emphasizes practical application of algorithmic and data-structure reasoning. It is commonly asked to verify correctness under out-of-order inserts and queries, to assess performance and complexity analysis for add/charge/get operations, and to require clear specification of time and space complexity for the proposed approach.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement follow graph with snapshotsHard

  This problem tests your ability to design a versioned, immutable, or persistent data structure that supports efficient graph modifications and point-in-time snapshot queries.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement follow graph with snapshots and recommendationsMedium

  This question evaluates design and implementation skills for mutable graph data structures with point-in-time snapshotting and recommendation ranking, testing knowledge of data structures, versioning, graph traversal, and algorithmic time/space complexity analysis.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement in-memory DB queryingMedium

  This question evaluates a candidate's competency in data structures, algorithms, and systems-level thinking for implementing query processing in an in-memory database, including projection, predicate filtering, ordering, and index design.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement in-memory KV store with serializationMedium

  This question evaluates skills in designing and implementing an in-memory key-value store with serialization, testing data structure design, API design (set/get/serialize/deserialize), serialization format selection, type fidelity for common Python types, and robust error handling.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen