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 1051–1080 of 1706 results

  • 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
  • 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
  • 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
  • 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
  • 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
  • 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
    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
  • 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
  • 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
  • OptiverHardSoftware Engineer
    Cargo Order Allocation Across Departing Planes

    This question evaluates competence in deterministic resource allocation, stateful simulation, and capacity-management under time constraints, exercising algorithmic reasoning and data-structure handling within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OptiverMediumSoftware Engineer
    Compare common data structures and uses

    Compare common data structures and uses evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • OptiverMediumSoftware Engineer
    Count nonnegative buy/sell sequences

    This question evaluates combinatorial reasoning and algorithmic analysis by asking for the count of constrained buy/sell sequences, testing competence in counting under constraints and reasoning about sequence invariants.

    Coding & AlgorithmsTechnical Screen
  • OptiverMediumSoftware Engineer
    Decide and implement DP/heap and approximation

    This question evaluates dynamic programming for counting constrained subsequences, priority-heap implementation and API robustness for job scheduling, and heuristic approximation methods for NP-hard selection problems, along with algorithmic complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • OptiverMediumSoftware Engineer
    Design a circular queue data structure

    This problem tests your ability to implement a fixed-capacity circular queue using a static array, focusing on efficient pointer arithmetic and state management.

    Coding & AlgorithmsTechnical ScreenData StructuresArraysQueues
  • OptiverMediumSoftware Engineer
    Design a queue and analyze tradeoffs

    This question evaluates understanding of FIFO data structures, algorithmic complexity analysis, memory and cache behavior, and concurrent access concerns.

    Coding & AlgorithmsTechnical Screen