Katkat

practice a little every day, paws crossed ♡

Coding & Algorithms 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 2101–2130 of 3276 results

  • 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
  • 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
  • OpenAIMediumMachine Learning Engineer
    Infer Generic Return Types

    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.

    Coding & AlgorithmsOnsiterecursiontreetype-systems
  • OpenAIHardSoftware Engineer
    Leftmost-Fit Memory Allocator: Allocate Consecutive Units and Free by Owner

    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.

    Coding & AlgorithmsOnsite
  • OpenAIHardSoftware Engineer
    Leftmost-Fit Theater Row Booking With Bulk Cancellation by Group

    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.

    Coding & AlgorithmsOnsitesegment-treeintervalssimulation
  • 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
  • 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
  • OpenAIHardSoftware Engineer
    Microorganism Eating Simulation: Largest Survivor After Left-to-Right Rounds

    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.

    Coding & AlgorithmsOnline Assessment
  • OpenAIMediumSoftware Engineer
    Minimize deaths in spreading plant infection

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

    Coding & AlgorithmsTechnical ScreenSimulationBFSGrid
  • OpenAIMediumSoftware Engineer
    Optimize C++ Performance with Provided Concurrency

    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.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Order Recipe Prep Steps Into the Smallest Valid Sequence

    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.

    Coding & AlgorithmsTechnical Screentopological-sortgraphsheap
  • OpenAIMediumSoftware Engineer
    Order Tasks with Dependencies Using a Deterministic Topological Sort

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

    Coding & AlgorithmsTechnical Screengraphtopological-sortheap
  • OpenAIMediumSoftware Engineer
    Rebalance shard ranges under overlap limit

    This problem tests interval manipulation and greedy optimization by requiring you to adjust a set of shard ranges so that no more than k ranges overlap at any integer point, while minimizing the number of boundaries moved.

    Coding & AlgorithmsTechnical ScreenAlgorithmsSweep-LineIntervals
  • OpenAIHardSoftware Engineer
    Refactor a chat message processing function

    This problem tests your ability to refactor procedural, error-prone code into a robust, extensible pipeline for parsing and managing chat message state.

    Coding & AlgorithmsTechnical ScreenRefactoringString-ManipulationOOP
  • OpenAIHardSoftware Engineer
    Resolve Short-Link Redirect Chains That May Loop

    Follow single-target redirects from a start code and return the final code, or the last code before the walk would revisit one. Then answer many starts in linear total time. Tests visited-set bookkeeping and functional-graph structure.

    Coding & AlgorithmsTechnical Screengraphsfunctional-graphcycle-detection
  • OpenAIMediumSoftware Engineer
    Return the Lexicographically Smallest Topological Order

    Implement a deterministic topological sort using a min-heap to return the lexicographically smallest ordering of a directed graph, or detect cycles and return an empty list.

    Coding & AlgorithmsOnsitegraphtopological-sortheap
  • OpenAIHardSoftware Engineer
    Rotate Couriers Daily at Minimum Total Cost

    Choose one courier company per day so that no company works two days in a row and the total price is minimal, then return the schedule. Tests DP over a small state, path reconstruction, and the best/second-best trick for k options.

    Coding & AlgorithmsTechnical Screendynamic-programmingreconstructionarrays
  • OpenAIHardMachine Learning Engineer
    Schedule Incremental Labeling Tasks

    This problem tests the ability to design an incremental task scheduler that balances workload across a pool of annotators while maintaining fairness and deterministic state transitions.

    Coding & AlgorithmsOnsiteHeapsSchedulingGreedy
  • OpenAIHardMachine Learning Engineer
    Search Monster Battle Strategies

    Design a search algorithm using state-space exploration to find the minimum number of turns required to defeat a boss given transient health, scripted boss attacks, and a single-use revive.

    Coding & AlgorithmsOnsiteBreadth-First SearchState Space SearchGraph Algorithms
  • OpenAIHardMachine Learning Engineer
    Simulate Infection Spread on a Grid

    Implement a discrete-time cellular automaton simulating epidemic spread on a 2D grid with multi-day infection states, immunity waning, and mortality rules.

    Coding & AlgorithmsTechnical ScreenSimulationMatrixCellular Automata
  • OpenAIMediumMachine Learning Engineer
    Simulate Infection Spread with Immunity and Recovery

    Implement a cellular automaton simulation modeling disease spread on a 2D grid with discrete cell states and timed recovery.

    Coding & AlgorithmsTechnical ScreenGrid SimulationCellular AutomataBFS
  • OpenAIHardMachine Learning Engineer
    Simulate Plant Infection With Controlled Burning

    This question evaluates a candidate's ability to implement discrete-time grid simulations with delayed state transitions, reason about simultaneous updates and neighborhood effects, and perform a limited combinatorial optimization (choosing one row or column) to minimize a global outcome.

    Coding & AlgorithmsOnsite
  • OpenAIMediumMachine Learning Engineer
    Simulate Turn-Based Monster Battles

    This problem tests your ability to design a stateful simulation engine that handles turn-based mechanics, complex status modifiers, and dynamic combat interactions.

    Coding & AlgorithmsOnsiteSimulationState ManagementGame Logic
  • OpenAIEasySoftware Engineer
    Simulate a Turn-Based Two-Player Game

    This problem tests your ability to design a robust state management system and implement validation logic for a rule-based game.

    Coding & AlgorithmsTechnical ScreenState ManagementAPI DesignSimulation
  • OpenAIMediumSoftware Engineer
    Spreading Contagion on a Grid

    Tests modeling multi-source breadth-first search (BFS) on a 2D grid to compute simultaneous state propagation across discrete time steps.

    Coding & AlgorithmsTechnical Screenmulti-source-bfsgraphsmatrix
  • OpenAIHardMachine Learning Engineer
    Streaming Entropy with Numerical Stability

    Implement an online, numerically stable algorithm to compute Shannon entropy over an unbounded stream of categorical tokens with O(1) updates.

    Coding & AlgorithmsTechnical Screenstreamingmathnumerical-computing
  • OpenAIMediumMachine Learning Engineer
    Track Expiring GPU Credits

    Design an in-memory credit ledger to track expiring GPU compute credits, support priority consumption, and manage resource debt.

    Coding & AlgorithmsOnsiteHeapDesignGreedy
  • OpendoorHardBackend Engineer
    Execute a TTL Key-Value Store with Transactions

    This problem tests the implementation of an in-memory key-value store supporting TTL expiration, atomic transactions with rollback capabilities, and logical time-based validation.

    Coding & AlgorithmsTechnical ScreenHashMapsTransactionsTTL
  • OptiverMediumSoftware Engineer
    Build and Validate a Binary Tree from Parent-Child Pairs

    This question evaluates understanding of tree and graph concepts, strict string parsing and validation, duplicate and cycle detection, and the construction of canonical S-expressions within the Coding & Algorithms category.

    Coding & AlgorithmsOnline Assessment