Coding & Algorithms interview questions

Showing 2101–2130 of 3276 results

• Implement persistent key-value storeMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Implement type AST and infer genericsHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Infection Spread Simulation with Death ThresholdMedium

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Infer Generic Return TypesMedium

  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.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Leftmost-Fit Memory Allocator: Allocate Consecutive Units and Free by OwnerHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Leftmost-Fit Theater Row Booking With Bulk Cancellation by GroupHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Manage GPU Credits with ExpirationMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Merge overlapping intervalsMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Microorganism Eating Simulation: Largest Survivor After Left-to-Right RoundsHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsOnline Assessment
• Minimize deaths in spreading plant infectionMedium

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Optimize C++ Performance with Provided ConcurrencyMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Order Recipe Prep Steps Into the Smallest Valid SequenceMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Order Tasks with Dependencies Using a Deterministic Topological SortMedium

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Rebalance shard ranges under overlap limitMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Refactor a chat message processing functionHard

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Resolve Short-Link Redirect Chains That May LoopHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Return the Lexicographically Smallest Topological OrderMedium

  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.

  OpenAISoftware EngineerCoding & AlgorithmsOnsite
• Rotate Couriers Daily at Minimum Total CostHard

  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.

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Schedule Incremental Labeling TasksHard

  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.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Search Monster Battle StrategiesHard

  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.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Simulate Infection Spread on a GridHard

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

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen
• Simulate Infection Spread with Immunity and RecoveryMedium

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

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen
• Simulate Plant Infection With Controlled BurningHard

  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.

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Simulate Turn-Based Monster BattlesMedium

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

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Simulate a Turn-Based Two-Player GameEasy

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Spreading Contagion on a GridMedium

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

  OpenAISoftware EngineerCoding & AlgorithmsTechnical Screen
• Streaming Entropy with Numerical StabilityHard

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

  OpenAIMachine Learning EngineerCoding & AlgorithmsTechnical Screen
• Track Expiring GPU CreditsMedium

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

  OpenAIMachine Learning EngineerCoding & AlgorithmsOnsite
• Execute a TTL Key-Value Store with TransactionsHard

  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.

  OpendoorBackend EngineerCoding & AlgorithmsTechnical Screen
• Build and Validate a Binary Tree from Parent-Child PairsMedium

  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.

  OptiverSoftware EngineerCoding & AlgorithmsOnline Assessment