Katkat

practice a little every day, paws crossed ♡

Interview Questions

Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.

9403
Questions
546
Companies
11
Topics
8
Languages

Showing 3031–3060 of 4616 results

  • OpenAIHardSoftware Engineer
    Implement a Contiguous Memory Allocator with Primitive Lists

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a Distributed Rate Limiter

    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.

    Coding & AlgorithmsTechnical ScreenDistributed SystemsConcurrencyAlgorithms
  • OpenAIMediumSoftware Engineer
    Implement a GPU credit manager

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a Recoverable In-Memory Key-Value Store

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

    Software Engineering FundamentalsTechnical ScreenSystemsConcurrencyPersistence
  • OpenAIMediumSoftware Engineer
    Implement a fault-tolerant work queue that never loses tasks when workers fail

    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.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a memory allocator with malloc/free

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement a minimal reverse-mode autograd engine on PyTorch tensors

    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.

    Machine LearningTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a serializable key-value store

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement an Extensible Chatbot App

    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.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement an IPv4 Range Iterator

    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.

    Coding & AlgorithmsTechnical ScreenBit ManipulationNetworkingIterator
  • OpenAIMediumSoftware Engineer
    Implement an expiring GPU credits ledger

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement and Debug Backprop in NumPy

    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.

    Machine LearningTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement delimiter-free string codec

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement expiring credit ledger

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement follow graph with snapshots

    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.

    Coding & AlgorithmsTechnical ScreenPersistent Data StructuresGraphsVersion Control
  • OpenAIMediumSoftware Engineer
    Implement follow graph with snapshots and recommendations

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement in-memory DB querying

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement in-memory KV store with serialization

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement malloc and free over Fixed Memory, Then Make Both Logarithmic

    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.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement node messaging and path discovery

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement persistent key-value store

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement type AST and infer generics

    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.

    Coding & AlgorithmsTechnical ScreenASTType InferenceRecursion
  • OpenAIHardMachine Learning Engineer
    Improve classifier with noisy multi-annotator labels

    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.

    Machine LearningTechnical Screen
  • OpenAIMediumSoftware Engineer
    Infection Spread Simulation with Death Threshold

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

    Coding & AlgorithmsTechnical Screenmatrixsimulationbreadth-first-search
  • OpenAIHardSoftware Engineer
    Key-Value Store Persistence: Length-Prefixed Bytes, Size-Capped Chunks, Thread Safety

    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.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIHardSoftware Engineer
    Lab Robot Job Dispatcher with Backoff, Quarantine and Prereqs

    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.

    Software Engineering FundamentalsTechnical Screenheapschedulingstate-machine
  • OpenAIMediumSoftware Engineer
    Lease-Based Job Queue for Flaky Render Workers

    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.

    Software Engineering FundamentalsTechnical Screenconcurrencyqueuesfault-tolerance
  • OpenAIMediumSoftware Engineer
    Manage GPU Credits with Expiration

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardData Scientist
    Measure free-month promotion impact

    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.

    Analytics & ExperimentationTechnical ScreenCausal InferenceExperiment DesignROI
  • OpenAIMediumSoftware Engineer
    Merge overlapping intervals

    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.

    Coding & AlgorithmsTechnical Screen