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 721–750 of 1080 results

  • NooksMediumSoftware Engineer
    Implement a BFS web crawler

    This question evaluates proficiency in breadth-first search and graph traversal concepts applied to web crawling, including handling duplicate links, hostname filtering, and tracking visited URLs.

    Coding & AlgorithmsOnsite
  • NotionMediumSoftware Engineer
    Find Top Errors in Time Window

    This problem tests your ability to process streaming log data within a sliding time window, aggregate frequencies using hash maps, and implement custom sorting logic.

    Coding & AlgorithmsOnsiteHash MapSortingData Processing
  • NuroHardBackend Engineer
    Implement BFS and a Job Scheduler

    Solve grid reveal with BFS and design a thread-safe periodic job scheduler. The solution covers Minesweeper-style expansion, queue processing, priority-queue scheduling, locks, worker pools, cancellation, duplicate prevention, long-running tasks, clock drift, and backpressure.

    Coding & AlgorithmsOnsite
  • OmnissaMediumSoftware Engineer
    Alternate Odd and Even Numbers with Two Threads

    This problem tests knowledge of thread synchronization using locks and condition variables to enforce a specific execution order between two concurrent processes.

    Coding & AlgorithmsOnsiteConcurrencyMultithreadingSynchronization
  • OmnissaMediumSoftware Engineer
    Check Whether a Singly Linked List Is a Palindrome

    Tests the ability to determine if a singly linked list is a palindrome in O(n) time and O(1) auxiliary space using two pointers and in-place list reversal.

    Coding & AlgorithmsOnsiteLinked ListTwo PointersIn-Place Reversal
  • OmnissaMediumSoftware Engineer
    Find the Celebrity from a Knows Matrix

    This problem tests the ability to solve a search problem in O(N) time by utilizing the transitive and exclusionary properties of the 'knows' relationship to eliminate candidates.

    Coding & AlgorithmsOnsiteArraysTwo PointersAlgorithms
  • OmnissaMediumSoftware Engineer
    Find the Maximum Sum of a Contiguous Subarray

    This problem tests the ability to implement Kadane's algorithm to find the maximum sum of a contiguous subarray, specifically focusing on handling negative integers and maintaining optimal time and space complexity.

    Coding & AlgorithmsOnsiteArraysDynamic ProgrammingKadane's Algorithm
  • OmnissaMediumSoftware Engineer
    Repeatedly Remove Adjacent Equal Characters

    This problem tests your ability to handle recursive reduction patterns in a string using a stack-based approach to achieve linear time complexity.

    Coding & AlgorithmsOnsiteStackStringGreedy
  • OpenAIMediumSoftware Engineer
    Add Consecutive-Value Bonuses to Grid Paths

    Tests dynamic programming on a 2D grid with extended state tracking to incorporate multi-step path history for score bonuses, path counting, and lexicographical path reconstruction.

    Coding & AlgorithmsOnsitedynamic-programminggridpathfinding
  • OpenAIHardSoftware Engineer
    Aggregate Recent Message Events And Active Chats

    Design an in-memory aggregation system that tracks rolling window message counts and distinct active entities across chats with bounded memory and O(1) amortized operations.

    Coding & AlgorithmsOnsiteSliding WindowData StreamsDesign
  • 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
  • OpenAIMediumSoftware Engineer
    Design a parser for a hypothetical language

    This question evaluates competency in compiler and language design, covering grammar analysis, parsing algorithms (LL/LR/GLR/Earley/PEG), lexer and parser implementation, AST construction, error reporting and recovery, operator precedence and associativity, and analysis of time/space trade-offs.

    Coding & AlgorithmsOnsite
  • OpenAIMediumMachine Learning Engineer
    Find Minimum Compatible Version

    Implement an algorithm to find the earliest compatible software version while minimizing expensive compatibility-check API calls across partitioned version branches.

    Coding & AlgorithmsOnsiteBinary SearchAlgorithmsOptimization
  • OpenAIMediumMachine Learning Engineer
    Find the First Working Version

    This question tests the ability to combine custom comparison logic with a binary search approach to identify the first transition point in a monotonic sequence.

    Coding & AlgorithmsOnsiteBinary SearchAlgorithmsOptimization
  • 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
  • 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 an IPv4 Iterator

    This problem tests your ability to handle IPv4 address arithmetic, bitwise operations, and the implementation of a stateful iterator that supports bidirectional traversal and range generation from CIDR notation.

    Coding & AlgorithmsOnsiteBit ManipulationIterator PatternNetworking
  • OpenAIHardSoftware Engineer
    Implement an in-memory SQL-like table

    This question evaluates implementation skills for an in-memory SQL-like table, focusing on data modeling with nested key-value structures, string handling, efficient lookups, and lexicographic sorting with tie-breaking.

    Coding & AlgorithmsOnsite
  • OpenAIHardMachine Learning Engineer
    Implement in-memory database insert and delete operations

    This question evaluates understanding of data structures and algorithmic complexity in the context of designing a key-value in-memory database, and it falls under the Coding & Algorithms domain for a Machine Learning Engineer role while focusing on practical implementation skills.

    Coding & AlgorithmsOnsite
  • 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
    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
  • 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 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
  • 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
  • OracleMediumBackend Engineer
    Add One to an Integer Stored as Digits Without ArrayList

    This problem tests array manipulation skills and the ability to handle carry-over logic in fixed-size numerical representations.

    Coding & AlgorithmsOnsiteArraysMathAlgorithms
  • OracleMediumSoftware Engineer
    Count Islands and Return the Largest Island Size

    Count four-connected islands and find the largest island using DFS or BFS, with correct visited-state handling and all-water behavior.

    Coding & AlgorithmsOnsite