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 151–180 of 1706 results

  • AmazonEasySoftware Engineer
    Validate Properly Nested Brackets

    Tests understanding of basic data structures—specifically stacks—to validate balanced and nested bracket sequences in linear time.

    Coding & AlgorithmsTechnical Screenstackstringsdata-structures
  • AmazonMediumSoftware Engineer
    Validate a training courses catalog

    This problem tests your ability to model prerequisites as a directed graph and detect circular dependencies using cycle detection algorithms (Kahn's or DFS).

    Coding & AlgorithmsTechnical ScreenGraphTopological SortDFS
  • Ambience HealthcareMediumSoftware Engineer
    Design a least-recently-used cache

    Design a least-recently-used cache 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
  • AmplitudeMediumSoftware Engineer
    Swap kth-from-end node with head

    This question evaluates a candidate's understanding of singly linked list pointer manipulation, in-place node swapping with O(1) extra memory, and handling of edge cases such as when the k-th node from the end is the head.

    Coding & AlgorithmsTechnical Screen
  • Anchorage DigitalMediumSoftware Engineer
    Design a dynamic leaderboard with rank queries

    This question tests the ability to maintain a dynamic set of scores and efficiently query the rank of a user, requiring a balance between update complexity and retrieval time.

    Coding & AlgorithmsTechnical ScreenData StructuresOrder StatisticsTrees
  • Anchorage DigitalMediumSoftware Engineer
    Print the File System State

    This problem tests your ability to recursively traverse a tree structure and format the output into a specific, ordered directory-style string representation.

    Coding & AlgorithmsTechnical ScreenTrieRecursionTrees
  • AndurilMediumSoftware Engineer
    Find Heap Objects Not Referenced by the Stack

    Implement a simplified mark-and-sweep sweep phase to identify unreferenced heap objects given a list of heap allocations and stack root pointers.

    Coding & AlgorithmsTechnical Screenhash-tablememory-managementarrays
  • AndurilMediumSoftware Engineer
    Find Unreachable Objects in a Heap Graph

    Implement a mark-phase reachability analysis for a heap graph starting from stack roots, returning unreachable heap addresses in their original order while handling cycles, self-references, and dangling pointers.

    Coding & AlgorithmsTechnical Screengraphsbfs-dfshash-table
  • AndurilMediumSoftware Engineer
    Maximize Profit From Cutting Rods

    This problem tests dynamic programming and optimization skills by requiring the calculation of the maximum profit obtainable from cutting a rod into integer-length pieces with given price values.

    Coding & AlgorithmsTechnical ScreenDynamic ProgrammingOptimizationAlgorithms
  • AnsysMediumSoftware Engineer
    Implement Prefix Search and Node Removal

    This question evaluates proficiency in string data structures and manipulation (prefix-search concepts including case-insensitive matching and regex-based normalization) as well as linked list pointer manipulation and in-place node removal.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Build a concurrent web crawler

    This question tests your ability to design a concurrent crawler that manages shared state across multiple threads, handles URL de-duplication, and prevents infinite cycles during graph traversal.

    Coding & AlgorithmsTechnical ScreenConcurrencyMultithreadingGraph Traversal
  • AnthropicMediumSoftware Engineer
    Compute exclusive times and call stack from logs

    This question evaluates a candidate's ability to process single-threaded execution logs and compute per-function exclusive durations while reconstructing the call stack at a given timestamp, testing stack simulation, interval reasoning, timestamp tie-handling, parsing of time-stamped events, and algorithmic complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Compute matrix trace and support updates

    This question evaluates proficiency in matrix manipulation, incremental updates, and complexity analysis, specifically maintaining main-diagonal and anti-diagonal sums under point updates.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumMachine Learning Engineer
    Convert Samples into Event Intervals

    This problem tests your ability to process sequential data, apply run-length encoding concepts, and implement filtering logic based on temporal constraints.

    Coding & AlgorithmsTechnical ScreenArrayIntervalsData Processing
  • AnthropicHardSoftware Engineer
    Convert Streaming Call-Stack Samples into Function Events

    Tests the ability to process discrete call-stack snapshots into properly nested, ordered function start and end events using longest common prefix analysis and stack unwinding.

    Coding & AlgorithmsTechnical Screenstackalgorithmsprofiling
  • AnthropicMediumMachine Learning Engineer
    Convert stack samples to execution trace

    This question evaluates understanding of sampled stack traces, event reconstruction, handling ambiguous or incomplete profiling data, and algorithmic reasoning about correctness and time/space complexity.

    Coding & AlgorithmsTechnical Screen
  • AnthropicHardSoftware Engineer
    Crawl Same-Domain Links

    This question evaluates understanding of web crawling and link traversal algorithms, including URL normalization, same-domain filtering, deduplication, and cycle-safe graph traversal.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design a single- and multi-threaded web crawler

    This question evaluates skills in web crawling, URL parsing and fragment sanitization, graph traversal for deduplication, and concurrent programming for thread-safe crawling, and it falls under the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Design file deduplication across nested directories

    This question evaluates a candidate's competency in file system traversal, robust I/O handling including symbolic links and cycles, content-based deduplication, and algorithmic efficiency within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicHardSoftware Engineer
    Design stack with O(1) minimum query

    This problem tests your ability to augment a standard stack with metadata to perform efficient minimum queries without sacrificing the constant-time complexity of stack operations.

    Coding & AlgorithmsTechnical ScreenStackData StructuresAlgorithms
  • AnthropicMediumSoftware Engineer
    Detect n-length consecutive sequences

    This question evaluates a candidate's competency in algorithm design and data-structure reasoning for detecting n-length consecutive integer sequences, encompassing handling of duplicates, negative values, and dynamic insertions and deletions.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Detect runs and answer suffix queries

    This question evaluates proficiency in array processing, run-length detection, algorithmic complexity analysis, and the use of range/suffix data structures within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicHardSoftware Engineer
    Find duplicate files and apply image operations

    This question evaluates skills in string parsing and content-based grouping for duplicate file detection, along with matrix manipulation for image operations like horizontal flips and box blur, covering competencies in algorithm design, data-structure selection, and numerical array transformations.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Fix a Corrupted Bootloader Instruction

    Simulate a virtual machine's instruction set, detect an infinite loop cycle, and find the single instruction modification (between jmp and nop) that allows the program to terminate normally.

    Coding & AlgorithmsTechnical Screensimulationgraphdepth-first-search
  • AnthropicMediumSoftware Engineer
    Generate Function Profiling Events from Stack Samples

    Generate function start and end events from timestamped stack samples, including independently debounced frames across consecutive samples. Address transient appearances and absences, changing stack suffixes, shared timestamps, deep stacks, end-of-input behavior, complexity, and online processing.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Generate outputs for images and pipelines

    This question evaluates algorithmic and systems engineering skills related to batch image processing, parallelization, I/O versus CPU trade-offs, and deterministic output association within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • AnthropicMediumSoftware Engineer
    Implement Task Management and Duplicate Detection

    This problem tests your ability to design an in-memory task management system with concurrency-aware state tracking and implement an efficient file-deduplication routine using hashing.

    Coding & AlgorithmsTechnical ScreenData StructuresHashingConcurrency
  • AnthropicMediumSoftware Engineer
    Implement a Batch Image Processor

    Design and implement an in-memory image transformation engine that applies sequential operations (grayscale, brightness scaling, nearest-neighbor resizing) over a batch of images efficiently.

    Coding & AlgorithmsTechnical ScreenParallelismMultiprocessingImage Processing
  • AnthropicMediumSoftware Engineer
    Implement a Parallel Image Processor

    Design and implement a concurrent batch image processor that executes a sequence of matrix transforms across worker threads or processes while isolating per-job failures.

    Coding & AlgorithmsTechnical Screenconcurrencymultithreadingfault-tolerance
  • AnthropicHardSoftware Engineer
    Implement a Time-Aware Task Manager

    Design an in-memory task manager supporting per-user task versioning, time-to-live (TTL) expiration, and point-in-time historical queries.

    Coding & AlgorithmsTechnical ScreenBinary SearchData StructuresDesign