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 6121–6150 of 9403 results

  • OpenAIHardMachine Learning Engineer
    Analyze matrix multiplication complexity

    This question evaluates understanding of time and space complexity for matrix multiplication and memory accounting in ML workloads, testing competency in asymptotic analysis, linear algebra operations, and resource estimation.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIHardData Scientist
    Assess free-month promotion impact

    This question tests your ability to design a rigorous experimentation framework to measure the causal impact of a promotional offer while accounting for self-selection bias and long-term churn behavior.

    Analytics & ExperimentationTechnical ScreenA/B TestingCausal InferenceProduct Analytics
  • OpenAIMediumSoftware Engineer
    At-Least-Once Job Queue with Timeouts, Retries, a Dead-Letter Queue and Dependencies

    Implement an in-memory job queue with enqueue, reserve, pass, fail and a dead-letter queue, where reservations that outlive their timeout are redelivered for at-least-once delivery, then extend enqueue with job dependencies. It tests state-machine design, timeout tracking, retry accounting and dependency handling.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Behavioral: why OpenAI, AI safety views, 0-to-1 work, feedback, defining success

    Behavioral questions reported from OpenAI's software engineering loop: why OpenAI, how you think about AGI and AI safety, a 0-to-1 project, negative feedback you received, and how you defined success for a project. A slide-based project deep dive then probes technical depth under repeated challenge, testing ownership, calibrated judgment and composure.

    Behavioral & LeadershipOnsite
  • OpenAIMediumAndroid Engineer
    Build a Compose Rating Card

    Tests proficiency in modern Android development with Kotlin and Jetpack Compose, focusing on unidirectional data flow (UDF), custom stateless composables, ViewModel state management, and asynchronous submission handling.

    Coding & AlgorithmsTechnical Screenandroidjetpack-composekotlin
  • OpenAIHardSoftware Engineer
    Build a Reliable Streaming Chat UI

    This question evaluates understanding of real-time front-end architecture and state management in React, focusing on transient streaming state, concurrency control, UI consistency during tokenized updates, and the appropriate use of hooks such as useRef versus useState in the Software Engineering Fundamentals domain.

    Software Engineering FundamentalsHR Screen
  • OpenAIMediumSoftware Engineer
    Build a SaaS API-Credit Ledger With Expiring Grants and Late Events

    Implement an API-credit ledger that grants, spends, and reports balances, where each grant expires and spending always draws from the soonest-expiring usable grant first, even when operations arrive out of timestamp order.

    Software Engineering FundamentalsOnsitedata-structuresheapevent-ordering
  • OpenAIMediumFrontend Engineer
    Build a Streaming Chat Input

    This question evaluates frontend engineering skills including streaming data handling, incremental token-by-token rendering, asynchronous state management, and preserving UI responsiveness during long-running API streams.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardMachine Learning Engineer
    Build and troubleshoot image classification and backprop

    Build and troubleshoot image classification and backprop evaluates core ML concepts, assumptions, math intuition, training/evaluation trade-offs, and practical failure modes in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Machine LearningTechnical Screen
  • OpenAIHardSoftware Engineer
    Cheapest Daily Shirt Colors With No Color Repeated on Consecutive Days

    Pick a blue, green or red shirt for each of n days so that the total price is as low as possible while never buying the same color on two consecutive days, and return the chosen color sequence. It tests dynamic programming over a small state space and reconstruction of the optimal choices.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Cheapest Paint-Booth Color Schedule With No Repeat on Consecutive Cars

    Choose one of three paint colors for each car on an assembly line to minimize total cost, never repeating a color on consecutive cars, and return the exact color chosen for each car.

    Coding & AlgorithmsTechnical Screendynamic-programmingreconstructiongreedy-vs-dp
  • OpenAIMediumSoftware Engineer
    Clarify a Machine Topology Coding Task

    Implement and formalize an API to analyze distributed accelerator interconnect topologies, separating summary metrics from component-level graph structures and validating topologies like rings, cliques, and lines.

    Software Engineering FundamentalsTechnical Screengraph-algorithmsbfsapi-design
  • OpenAIMediumSoftware Engineer
    Clarify and Design Social-Graph Milestones

    Clarify ambiguous social-graph milestones before designing follow and unfollow operations, consistent snapshots, and user recommendations. The discussion tests directed-edge semantics, snapshot guarantees, recommendation-policy choices, exclusions, deterministic tie rules, scale assumptions, and contract-focused testing.

    Software Engineering FundamentalsOnsite
  • OpenAIHardSoftware Engineer
    Compute Infection Time in a Grid

    This problem tests your ability to model state propagation in a 2D grid using Breadth-First Search (BFS) to determine the time required for a dynamic condition to cover all reachable nodes.

    Coding & AlgorithmsTechnical ScreenBFSGraphSimulation
  • OpenAIHardMachine Learning Engineer
    Compute Matrix Prefix Products And Gradients

    This question evaluates understanding of automatic differentiation for matrix operations, specifically forward and reverse-mode gradients for sequential, associative (but noncommutative) matrix products, together with algorithmic analysis of time and space complexity.

    Machine LearningOnsite
  • OpenAIMediumSoftware Engineer
    Compute Plant Infection Stabilization

    This problem tests your ability to simulate state propagation across a grid over discrete time steps and determine the minimum number of interventions required to contain an infection.

    Coding & AlgorithmsTechnical ScreenSimulationGridBacktracking
  • OpenAIMediumSoftware Engineer
    Compute Plant Infection Time

    This problem tests your ability to model a grid-based propagation process using Breadth-First Search (BFS), specifically handling multi-source initialization and obstacle avoidance.

    Coding & AlgorithmsTechnical ScreenBFSGraphGrid
  • OpenAIHardData Scientist
    Compute churn with re-subscriptions

    This problem tests your ability to reconstruct user subscription states over time from raw event logs, specifically identifying active status to calculate monthly churn rates.

    Data Manipulation (SQL/Python)Technical ScreenSQLData ManipulationTime-series
  • OpenAIMediumMachine Learning Engineer
    Compute entropy and implement 1-NN

    This question evaluates numerical stability and streaming computation for entropy estimation from logits, along with efficient vectorized linear-algebra implementation of 1-nearest-neighbor inference and its interpretation as a neural-network forward pass under different distance metrics.

    Machine LearningOnsite
  • OpenAIMediumSoftware Engineer
    Compute infection spread time

    This problem tests your ability to model a spreading process on a 2D grid using a multi-source Breadth-First Search (BFS) to determine the time required for a state to propagate across the entire space.

    Coding & AlgorithmsOnsiteBFSGraphsGrid
  • OpenAIEasyData Scientist
    Compute signup rate and retention from raw logs

    This question evaluates the ability to manipulate event-level logs to compute cohort metrics—specifically signup rate and D30 retention—testing proficiency in SQL/Python, event-time windowing, joins, aggregation, and understanding of upstream logging semantics.

    Data Manipulation (SQL/Python)Technical Screen
  • OpenAIHardSoftware Engineer
    Contiguous Extent Allocator for a Storage Volume, Then O(log n)

    Build an allocator that hands out contiguous runs of blocks on a fixed-size volume and takes them back with coalescing, first with a simple sorted list and then with logarithmic reserve and release. Tests splitting/merging logic, choosing indexes for size and neighbor lookups, and keeping them consistent.

    Software Engineering FundamentalsTechnical Screenallocatordata-structuresbalanced-bst
  • OpenAIMediumBackend Engineer
    Convert IPv4 Ranges to CIDR Blocks

    This question evaluates understanding of IPv4 addressing, binary/bitwise manipulation, and the ability to summarize consecutive address ranges into minimal CIDR blocks, and belongs to the Coding & Algorithms domain for backend engineering roles.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Count Connected Friend Groups

    Determine the number of connected components in an undirected graph represented as an adjacency matrix using graph traversal or disjoint set union.

    Coding & AlgorithmsTechnical Screengraphdfsbfs
  • OpenAIHardSoftware Engineer
    Count Events in a Trailing 15-Minute Window with a Fixed-Size Ring Buffer

    Implement an event counter that returns how many events occurred in the trailing 15 minutes, using a fixed-size ring buffer of per-second buckets so memory stays bounded at any event rate. It tests circular buffers, stale-slot detection, window boundaries, late events and thread safety.

    Software Engineering FundamentalsOnsite
  • OpenAIMediumSoftware Engineer
    Count Machines and Recover a Distributed Tree Topology

    Implement a distributed tree discovery and aggregation protocol that counts reachable machines, recovers edges, handles network retries, detects unreachable subtrees, and validates tree invariants.

    Software Engineering FundamentalsTechnical ScreenDistributed SystemsTreeGraph Traversal
  • OpenAIHardSoftware Engineer
    Count Ordered Four-Shop Road Paths That Visit One Shop of Each Type

    Count the ordered routes through a town's road network that visit exactly one shop of each of four types, where consecutive shops must share a direct road and a route and its reverse count separately. Tests graph modeling, path enumeration under type constraints and careful counting on small graphs.

    Coding & AlgorithmsOnline Assessment
  • OpenAIMediumMachine Learning Engineer
    Debug MiniGPT and Backpropagate Matmul

    This question evaluates proficiency in debugging PyTorch transformer implementations, reasoning about attention mechanics and causal masking, implementing key–value caching for autoregressive decoding, and constructing provably correct backward passes for matrix multiplications and custom autograd.Functions.

    Machine LearningTechnical Screen
  • OpenAIMediumMachine Learning Engineer
    Debug Transformer and Add KV Cache

    This problem tests your understanding of transformer architecture by requiring you to fix a broken attention mechanism and implement a Key-Value cache to optimize autoregressive inference.

    Machine LearningOnsiteTransformersAttentionInference
  • OpenAIMediumMachine Learning Engineer
    Debug a Concurrent Job Scheduler

    This question evaluates debugging and hardening skills for concurrent systems, focusing on detection and reasoning about race conditions, deadlocks, lock-contention hotspots, state-machine invariant enforcement, rate-limiting, retry semantics, and instrumentation for per-job metrics in a job scheduler.

    Software Engineering FundamentalsTechnical Screen