Katkat

practice a little every day, paws crossed ♡

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 9403 results

  • AmazonEasySoftware Engineer
    Implement Interview Coding Problems

    This question evaluates implementation and algorithmic skills across core data structures and array/interval algorithms, specifically hashing (hash map design including collision handling and resizing), interval merging and intersection logic, and array optimization problems such as maximum container area and trapped rainwater.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumApplied Scientist
    Implement K-means and solve interval/frequency tasks

    This multi-part question evaluates understanding of K-means clustering, interval-merging algorithms, and frequency-based top-k retrieval, assessing competencies in unsupervised learning concepts, algorithmic problem solving, data structures, and complexity analysis.

    Coding & AlgorithmsOnsite
  • AmazonMediumSoftware Engineer
    Implement LRU cache with O(1) ops

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Implement LRU cache with O(1) ops states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsOnsite
  • AmazonMediumApplied Scientist
    Implement Multi-Head Attention from Scratch in NumPy

    This problem tests your understanding of Transformer components by requiring an implementation of Multi-Head Scaled Dot-Product Attention using only NumPy, emphasizing matrix manipulations and numerical stability.

    Coding & AlgorithmsOnsiteTransformersNumPyAttention
  • AmazonMediumMachine Learning Engineer
    Implement Multi-Head Attention with a KV Cache and Cached Grouped-Query Attention

    Implement causal multi-head attention from scratch, add a key-value cache for token-by-token decoding, and extend the forward pass to grouped-query attention, where several query heads share one key and value head. Tests tensor shape discipline, masking with cached positions, and reasoning about decode compute and cache memory.

    Machine LearningOnsite
  • AmazonHardApplied Scientist
    Implement Optimal Bucket Batching

    This question evaluates algorithm design and optimization skills, focusing on combinatorial partitioning and batching strategies, efficient utilization of parallel GPUs, and time/space complexity analysis relevant to ML data pipelines.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumApplied Scientist
    Implement PyTorch training loop

    This question evaluates practical implementation skills in PyTorch, focusing on model and device management, batch-wise training mechanics, gradient handling, and optimizer interaction.

    Coding & AlgorithmsOnsite
  • AmazonEasySoftware Engineer
    Implement Regular Expression Matching

    This problem tests your ability to handle recursive string matching problems using dynamic programming, specifically focusing on handling wildcard and repetition operators.

    Coding & AlgorithmsTechnical ScreenDynamic ProgrammingStringsRecursion
  • AmazonMediumData Scientist
    Implement Reservoir Sampling; Analyze Time and Space Complexity

    This question evaluates understanding of streaming randomized algorithms and probabilistic reasoning—specifically reservoir sampling—along with analysis of time and space complexity and use of hash-based structures for duplicate detection; it is in the Coding & Algorithms domain and tests both conceptual probability invariants and practical implementation skills. Such problems are commonly asked to gauge a candidate's ability to design one-pass, linear-time solutions for unbounded data streams and to reason about algorithmic correctness and resource bounds in technical interviews.

    Coding & AlgorithmsOnsite
  • AmazonMediumSoftware Engineer
    Implement Review Content Moderation

    This problem tests your ability to design a content moderation service that efficiently checks for prohibited words and maintains a running count of violations per user using a stateful metadata store.

    Software Engineering FundamentalsOnline AssessmentHash MapsData StructuresState Management
  • AmazonMediumApplied Scientist
    Implement SGD for linear regression and derive gradients

    This question evaluates understanding of gradient-based optimization and linear model training, including competency in deriving gradients for mean squared error and implementing stochastic (or mini-batch) gradient descent for parameter estimation.

    Machine LearningTechnical Screen
  • AmazonMediumApplied Scientist
    Implement Top-p (Nucleus) Sampling in NumPy

    This problem tests your ability to implement the nucleus sampling algorithm from scratch using NumPy, focusing on probability distribution processing and efficient array masking.

    Coding & AlgorithmsOnsiteNumPyNLPProbability
  • AmazonHardSoftware Engineer
    Implement a Half-Open Interval Range Module

    This problem tests proficiency with balanced binary search trees or interval management techniques to efficiently track and manipulate sets of half-open intervals.

    Coding & AlgorithmsTechnical ScreenIntervalsBinary SearchData Structures
  • AmazonMediumSoftware Engineer
    Implement a Min-Priority Queue Without a Library Heap

    Tests implementation of a binary min-heap from scratch, including array-based representation, sift-up, and sift-down operations, without relying on built-in priority queue libraries.

    Coding & AlgorithmsOnsiteHeapData StructuresDesign
  • AmazonMediumSoftware Engineer
    Implement a Single-Node Priority Pub/Sub

    This question evaluates understanding of concurrent system design, in-memory publish–subscribe semantics, prioritized delivery ordering, API and data structure selection, and thread-safety within the Software Engineering Fundamentals domain.

    Software Engineering FundamentalsOnsite
  • AmazonMediumSoftware Engineer
    Implement a formatted shell script output

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Implement a formatted shell script output states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumData Scientist
    Implement a high-throughput web crawler safely

    This question evaluates competency in concurrent systems, scalable data ingestion, and algorithmic design for a high-throughput web crawler, covering URL normalization, deduplication, per-host rate limiting, fault-tolerant checkpointing, and bounded-memory queueing.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumSoftware Engineer
    Implement a robust shell CLI

    This question evaluates proficiency in POSIX-compliant shell scripting, including positional argument parsing and validation, ISO 8601 UTC timestamp generation, file metadata extraction for license determination, construction of user@hostname, error handling and exit-code semantics, and handling of non-ASCII file paths.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumSoftware Engineer
    Implement ad matching and delivery routing

    Implement ad matching and delivery routing 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
  • AmazonMediumFrontend Engineer
    Implement an Accessible Autocomplete Search Component

    Design and implement an accessible, race-condition-resilient autocomplete search component in React or modern JavaScript, focusing on debounced queries, ARIA combobox semantics, and keyboard navigation.

    Software Engineering FundamentalsTechnical ScreenReactAccessibilityFrontend
  • AmazonMediumData Scientist
    Implement and Analyze 'Merge k Sorted Lists' Algorithm

    This question evaluates algorithm design skills and complexity analysis for merging multiple sorted sequences, measuring proficiency with appropriate data structures, time-space trade-offs, and correctness reasoning.

    Coding & AlgorithmsOnsite
  • AmazonMediumSoftware Engineer
    Implement and Analyze an LRU Query Cache

    Implement a fixed-capacity least-recently-used cache for integer query results with expected constant-time get and put operations. Refresh recency on hits and updates, evict the correct key on overflow, and handle misses and duplicate puts precisely.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumSoftware Engineer
    Implement basic calculator

    This question evaluates skill in parsing and evaluating arithmetic expressions with integer operands and the operators +, -, *, and /, focusing on operator precedence and evaluation order within the Coding & Algorithms domain.

    Coding & AlgorithmsOnline Assessment
  • AmazonMediumApplied Scientist
    Implement binary search lower/upper bounds

    Implement lower_bound and upper_bound on a non-decreasing sorted array using iterative binary search in O(log n) time and O(1) space. This Amazon ML engineer screen tests precise boundary handling, loop-invariant reasoning, and edge cases like duplicates, empty arrays, and out-of-range targets.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumApplied Scientist
    Implement decoder-only GPT-style transformer

    This question evaluates implementation-level mastery of transformer architectures, including multi-head masked self-attention, position-wise feed-forward networks, residual connections, and precise tensor-shape reasoning for a decoder-only language model, within the Coding & Algorithms domain of deep learning and neural network engineering.

    Coding & AlgorithmsOnsite
  • AmazonMediumApplied Scientist
    Implement integer division without using division

    This question evaluates proficiency in implementing low-level integer arithmetic and algorithmic optimization, including correct handling of overflow and edge cases within 32-bit signed integer constraints.

    Coding & AlgorithmsOnsite
  • AmazonMediumApplied Scientist
    Implement inventory allocation with backorders

    Implement inventory allocation with backorders 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 & AlgorithmsOnsite
  • AmazonMediumData Scientist
    Implement list overlap and dense-ranked word frequencies

    This question evaluates a data scientist's ability to implement efficient multiset intersection and streaming top-k word-frequency computations, covering duplicate-aware counting, dense-ranking, Unicode handling, and strict time/space constraints.

    Coding & AlgorithmsOnsite
  • AmazonMediumSoftware Engineer
    Implement robust debounce and throttle in JavaScript

    This question evaluates a developer's ability to implement debounce and throttle utilities in JavaScript, testing competencies in asynchronous timing, timer management, cancellation/flush semantics, error propagation, and handling edge cases such as rapid bursts, timer drift, and re-entrancy.

    Coding & AlgorithmsTechnical Screen
  • AmazonMediumData Scientist
    Implement streaming k-way merge with constraints

    This question evaluates competence in streaming algorithms and resource-constrained algorithm design, specifically implementing a k-way merge over blocking, potentially unbounded integer iterators while preserving stable duplicates and reasoning about time and O(k) space complexity.

    Coding & AlgorithmsOnsite