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 6331–6360 of 9403 results

  • OpenAIHardSoftware Engineer
    Follow Graph with Cheap Snapshots and Top-K Follow Recommendations

    Build a one-directional follow graph that supports cheap snapshots and queries against past snapshots, then recommend the top k accounts a user should follow. It tests versioned data structures, snapshot semantics, two-hop graph traversal, heap-based top-k selection and scaling to highly connected accounts.

    Software Engineering FundamentalsOnsite
  • OpenAIHardSoftware Engineer
    Follow One-Way Links to the Endpoint Node or the Last Node Before a Loop Closes

    Given one-way links in which every node has at most one outgoing link, follow the links from a start node and return the endpoint where the walk stops, or the last node visited before the walk would revisit a node. Tests single-successor graph traversal, visited-node bookkeeping and loop edge cases.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    GPU Credit Ledger with Expiring Grants, Out-of-Order Operations and Fast Balances

    Implement a GPU credit ledger with expiring grants, subtractions that spend the soonest-expiring credits first, and balance queries, where operations can arrive out of timestamp order. Then avoid recomputing from time zero on every query. It tests event replay, priority queues and checkpoint invalidation.

    Software Engineering FundamentalsOnsite
  • OpenAIMediumSoftware Engineer
    GPU Credit Ledger: Spend Earliest-Expiring Credits First, Stop on Overdraft

    A coding and design question about an in-memory GPU credit ledger that grants expiring credits, charges usage against the credit that expires soonest, and returns no balance once any charge overdraws the account. It tests data structure choice, expiry and boundary conventions, and optimizing the ledger for a very large number of credit changes.

    Software Engineering FundamentalsOnsite
  • OpenAIMediumSoftware Engineer
    Game Telemetry Windows: Match Counts, Live Sessions, Late Events

    Build an in-memory service that counts per-match actions inside a global 10-minute window, tracks each player's live client sessions from heartbeats and logouts, and stays correct when events arrive late. Tests bounded-memory eviction, amortized analysis, lazy deletion and exact window semantics.

    Software Engineering FundamentalsOnsitesliding-windowheapqueue
  • OpenAIMediumSoftware Engineer
    Generate Data Labeling Schedules

    This question evaluates combinatorial reasoning and constructive algorithm design for generating constrained assignment schedules, including ensuring each human appears a minimum number of times, preventing duplicate human-task pairs, and managing valid ID ranges.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardMachine Learning Engineer
    Hand-Rolled Backprop: Running Product and Stable Cross-Entropy

    Derive and implement, without an autodiff library, the backward pass of a running (cumulative) product in linear time without division, then a numerically stable softmax cross-entropy and its gradient. Tests chain-rule fluency, prefix/suffix tricks, and gradient checking.

    Machine LearningOnsiteautodiffbackpropagationnumerical-stability
  • OpenAIHardMachine Learning Engineer
    Hand-Written Gradients: Prefix-Product Backward Pass and Stable Cross-Entropy

    Write gradients by hand: the forward and backward pass of the prefix-product operation, in linear time and without division so inputs may contain zeros, and a numerically stable softmax cross-entropy loss with its gradient in NumPy. It tests the chain rule, prefix and suffix products, and gradient checking.

    Machine LearningOnsite
  • OpenAIHardData Scientist
    Handle repeated churn in SQL

    This problem tests your ability to handle complex temporal data by identifying user churn and re-subscription events, then calculating metrics like tenure and churn count per user.

    Data Manipulation (SQL/Python)Technical ScreenSQLWindow FunctionsTime Series
  • OpenAIHardSoftware Engineer
    Hiring manager call: walk through your past work, interests and latest project

    A hiring manager asks you to describe what you have built, what you want to work on next, and the project you worked on most recently, then describes their own team. Tests whether you can tell a concise career story, separate your own contribution from the team's, and defend the technical decisions of a recent project in depth.

    Behavioral & LeadershipTechnical Screen
  • OpenAIHardSoftware Engineer
    How to answer common recruiter screen questions

    How to prepare for an OpenAI software-engineering recruiter / HR phone screen. Covers the full set of common screen questions — self-intro, work-setup and sponsorship logistics, employment history and departure narrative, promotion and leadership-vs-coding deep-dives, an ambiguity STAR story, search-timeline and 'why OpenAI', referral context, and compensation — with model answers, a STAR framework, and the mistakes that sink candidates.

    Behavioral & LeadershipHR Screen
  • OpenAIMediumData Scientist
    How would you evaluate a free-trial A/B test?

    Evaluates skills in A/B test design and causal inference within the Analytics & Experimentation domain, emphasizing precise metric definition (including guardrails), choice of analysis population (ITT vs per‑protocol), handling of post‑treatment selection, and interpretation of binary conversion and retention metrics; the abstraction level is technical and oriented toward intermediate-to-senior data scientists who must combine statistical rigor with product impact thinking. Commonly asked because it tests the ability to balance acquisition versus downstream retention and revenue, to identify typical analysis pitfalls (time-window errors, incorrect joins/denominators, leakage, peeking, and selection bias), and to translate experiment results into a business recommendation linked to value metrics like LTV and payback period.

    Analytics & ExperimentationTechnical Screen
  • OpenAIMediumData Scientist
    Identify Bugs in Python Script for User Assignment

    This question evaluates a candidate's ability to detect bugs and data-quality risks in a Python script, testing competencies in code review, reproducible randomization, idempotency, logging, duplicate-exposure safeguards, and safe experiment-assignment logic.

    Coding & AlgorithmsOnline Assessment
  • OpenAIMediumMachine Learning Engineer
    Implement 1NN with NumPy

    Tests your ability to implement a fast, vectorized 1-Nearest Neighbor (1NN) classifier using NumPy, focusing on memory-efficient distance computations and tie-breaking.

    Machine LearningTechnical Screennumpyvectorizationmachine-learning
  • OpenAIMediumSoftware Engineer
    Implement A Contiguous Memory Allocator With Free-Block Coalescing

    Design a fixed-size contiguous memory allocator supporting allocation and deallocation with immediate adjacent free-block coalescing.

    Coding & AlgorithmsTechnical ScreenData StructuresIntervalsBinary Search
  • OpenAIMediumiOS Engineer
    Implement A Mobile Chat Interface In An Existing Codebase

    Tests your ability to design and implement a streaming chat interface state manager in an existing mobile codebase, focusing on async token streaming, state modeling, cancellation, and error handling.

    Software Engineering FundamentalsTechnical ScreeniOSSwiftConcurrency
  • OpenAIEasySoftware Engineer
    Implement Chat Event Counter

    This question evaluates data structures and algorithms competency, focusing on designing efficient in-memory counters and time-windowed event aggregation for (userId, chatId) pairs; it is categorized under Coding & Algorithms and has a practical implementation focus.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement Disease and Friend Snapshot Models

    This question evaluates skills in graph-based modeling and temporal state simulation as well as the design and implementation of snapshot-capable directed graph data structures, covering competencies in propagation and state transitions (including immunity, recovery, and death), efficient snapshotting, querying, ranking, and diffing of follow relationships. It is commonly asked to assess algorithmic reasoning, correctness under edge cases, and complexity-aware implementation; the problem belongs to the Coding & Algorithms domain and tests both conceptual understanding of dynamic graph behavior and practical application-level implementation of data structures and immutable snapshots.

    Coding & AlgorithmsOnsite
  • OpenAIMediumSoftware Engineer
    Implement GPU credit ledger

    This question evaluates a candidate's ability to design efficient stateful systems and algorithmic data structures for tracking per-tenant resource balances, including handling idempotency, negative balance policies, concurrency, and persistence.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement IP Address Arithmetic

    Implement parsing, binary representation, arithmetic offsets, and canonical formatting for both IPv4 and IPv6 addresses and CIDR subnets.

    Coding & AlgorithmsOnsitebit-manipulationstring-parsingnetworking
  • OpenAIMediumSoftware Engineer
    Implement IPv4 and CIDR iterators

    This problem tests your ability to manipulate IP address bit-representations and implement a custom iterator to traverse all addresses within a given CIDR block.

    Coding & AlgorithmsTechnical ScreenBitwiseNetworkingIterator
  • OpenAIMediumSoftware Engineer
    Implement KV store and plan type conversions

    This question evaluates proficiency in designing scalable, time-versioned key-value data structures and in graph-based shortest-path planning for costed type conversions, assessing algorithmic thinking, complexity analysis, and robustness under large-scale constraints in the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement KV store serialization

    This question evaluates skills in binary serialization and deserialization, data encoding and layout, type tagging, endianness, checksumming, versioning for forward/backward compatibility, and algorithmic efficiency and space usage for an in-memory key-value store; it falls under the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumMachine Learning Engineer
    Implement Masked Cross-Entropy with Label Smoothing

    Implement a numerically stable, masked cross-entropy loss function with label smoothing and temperature scaling in NumPy, returning both the loss and analytical gradients.

    Machine LearningTechnical Screenmachine-learningnumpydeep-learning
  • OpenAIMediumData Scientist
    Implement NumPy neural-network layers

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

    Machine LearningOnsiteNumPyNeural NetworksDeep Learning
  • OpenAIMediumMachine Learning Engineer
    Implement Prefix Products and Their Backward Pass

    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.

    Machine LearningOnsite
  • OpenAIMediumSoftware Engineer
    Implement Social Follow Recommendations

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

    Coding & AlgorithmsTechnical ScreenGraphHash MapSorting
  • OpenAIMediumSoftware Engineer
    Implement Social Graph Snapshot Queries

    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.

    Coding & AlgorithmsTechnical ScreenGraphsAdjacency ListData Structures
  • OpenAIMediumSoftware Engineer
    Implement Three Research Coding Tasks

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

    Coding & AlgorithmsHR ScreenNumerical StabilityDynamic ProgrammingStreaming Algorithms
  • OpenAIMediumSoftware Engineer
    Implement Time-Aware GPU Credit Ledger

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

    Coding & AlgorithmsTechnical ScreenHeap / Priority QueueDesignGreedy