Katkat

practice a little every day, paws crossed ♡

Machine Learning Engineer 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 61–90 of 253 results

  • GleanMediumMachine Learning Engineer
    Determine Reachability in Train Schedule

    Solve train-schedule reachability with waiting and transfers using time-respecting graph search. The answer models earliest station arrival, preprocesses station visits, handles forward-only train routes, and explains transfer edge cases and complexity.

    Coding & AlgorithmsTechnical Screen
  • GleanMediumMachine Learning Engineer
    Find Earliest Train Route

    This question evaluates a candidate's ability to model and search time-dependent transit networks, combining temporal graph reasoning, state-space search, and path reconstruction for itinerary reporting.

    Coding & AlgorithmsOnsite
  • GleanMediumMachine Learning Engineer
    Implement Rate-Limited Wikipedia Crawler

    This question evaluates a candidate's ability to implement a rate-limited web crawler, testing skills in crawl frontier management, prioritization by page-title initial, deduplication, rate limiting, and robust error handling.

    Coding & AlgorithmsOnsite
  • Goldman SachsHardMachine Learning Engineer
    Complete decision tree and gradient descent functions

    This question evaluates implementation skills in supervised machine learning and numerical optimization, specifically computing Gini impurity and selecting optimal binary splits for a decision tree alongside deriving and applying a single-step gradient descent update for linear regression.

    Coding & AlgorithmsOnline Assessment
  • GoogleMediumMachine Learning Engineer
    Compute sum over consecutive-step subarrays

    This problem tests your ability to identify contiguous subarrays that follow an arithmetic progression with a common difference of 1 (consecutive steps) and calculate the sum of elements within these subarrays efficiently.

    Coding & AlgorithmsOnsiteArraysMathSliding Window
  • GoogleHardMachine Learning Engineer
    Construct connected crop layout and safe paths

    This problem tests your ability to design a constructive grid layout that satisfies connectivity and size constraints, followed by pathfinding through dynamic or constrained environments.

    Coding & AlgorithmsTechnical ScreenBacktrackingGraph TheoryBFS
  • GoogleMediumMachine Learning Engineer
    Implement a Transformer Block with SwiGLU

    This question evaluates implementation and reasoning skills for Transformer internals, testing competency in multi-head self-attention, SwiGLU gated feed-forward layers, residual connections, and layer normalization within the Machine Learning / deep learning domain.

    Coding & AlgorithmsTechnical Screen
  • GoogleMediumMachine Learning Engineer
    Implement substring search and weighted sampling

    This question tests the ability to implement a fast substring matching algorithm and a data structure that supports weighted random sampling from a dynamic collection of items.

    Coding & AlgorithmsTechnical ScreenString MatchingKMPProbability
  • GoogleMediumMachine Learning Engineer
    Minimize Fence Painting Operations

    This problem tests your ability to use a greedy approach or dynamic programming to find the minimum number of strokes required to paint a fence of varying heights.

    Coding & AlgorithmsTechnical ScreenGreedyStackArrays
  • GoogleHardMachine Learning Engineer
    Solve several streaming, DAG, and DP tasks

    Implement an ML pipeline optimization engine that calculates critical path latency and peak parallelism for a task DAG, and optimizes streaming checkpoint placement under sliding-window constraints using dynamic programming.

    Coding & AlgorithmsOnsiteDAGDynamic ProgrammingSliding Window
  • HackerRankMediumMachine Learning Engineer
    Count Good Subsequences With Equal Character Frequencies

    Practice a combinatorics coding problem that counts good subsequences where every selected character has the same frequency. The prompt targets frequency counting, combinations, modular arithmetic, and grouping subsequences by common selected count.

    Coding & AlgorithmsOnline Assessment
  • HarveyMediumMachine Learning Engineer
    Implement a Spreadsheet With Formulas

    This problem tests your ability to model cell dependencies using a directed graph, handle topological sorting for re-evaluation, and identify circular references.

    Coding & AlgorithmsTechnical ScreenGraphsRecursionDFS
  • Hudson River TradingEasyMachine Learning Engineer
    Count People Reaching the Boundary

    This question evaluates algorithmic simulation and event-driven modeling skills, specifically handling discrete versus continuous time, visibility constraints relative to a stationary watcher that changes facing direction, and boundary conditions for state transitions.

    Coding & AlgorithmsOnsite
  • InstacartHardMachine Learning Engineer
    Solve Two Sorted-Array Tasks

    This problem tests your ability to efficiently merge and find elements in sorted arrays, focusing on optimal time complexity and edge case handling.

    Coding & AlgorithmsTechnical ScreenArraysBinary SearchTwo Pointers
  • J.P. MorganMediumMachine Learning Engineer
    Return Every Index Pair Whose Values Sum to a Target

    This problem tests your ability to handle frequency counts and index tracking using hash maps to identify all possible index pairs that sum to a specific target, particularly in the presence of duplicate values.

    Coding & AlgorithmsTechnical ScreenHash MapArraysAlgorithms
  • Jane StreetMediumMachine Learning Engineer
    Board Simulation: Bottom-Insert Pieces with Uniform Row and Column Detection

    This question evaluates the ability to simulate a 2-D game board and maintain dynamic state invariants, testing array manipulation, state-tracking, and detection of uniform rows and columns under bottom-insert semantics.

    Coding & AlgorithmsTechnical Screen
  • Jane StreetMediumMachine Learning Engineer
    Code Editor with Block Shrink and Expand (Code Folding)

    This question evaluates a candidate's ability to model and manipulate indentation-based hierarchical structures, maintain nested visibility state for collapsed blocks, and map between original file lines and dynamic display numbering.

    Coding & AlgorithmsTechnical Screen
  • Jane StreetMediumMachine Learning Engineer
    Connect-N on an Infinite Board with Gravity

    This question evaluates implementation skills for efficient algorithms and data structures to manage a sparse, unbounded grid with gravity and to detect N-in-a-row runs both vertically and horizontally.

    Coding & AlgorithmsTechnical Screen
  • Jane StreetEasyMachine Learning Engineer
    Marketplace Data Store: Order Matching and End-of-Day Reconciliation

    This question evaluates understanding of stateful data structures, deterministic order-matching logic, and time-ordered reconciliation of transaction logs, focusing on correct handling of pricing, tie-breaking, and re-opened inventory.

    Coding & AlgorithmsTechnical Screen
  • Jump TradingMediumMachine Learning Engineer
    Solve stock trading with pattern rules

    This set of problems evaluates algorithmic skills in pattern recognition, state management, and sequence processing, specifically testing pattern-based decision rules on time-series stock data and iterative substring elimination in string processing within the Coding & Algorithms domain.

    Coding & AlgorithmsOnline Assessment
  • Jump TradingMediumMachine Learning Engineer
    Solve stock-pattern trading and substring elimination

    This question evaluates algorithmic skills in array pattern recognition and string processing, specifically detecting day-to-day sign patterns for simulated trading and repeated elimination of fixed two-character substrings; it belongs to the Coding & Algorithms domain for a Machine Learning Engineer position and targets practical application of linear-time, constant-extra-space techniques. It is commonly asked to evaluate efficient O(n) algorithm design, handling of stateful streaming simulations and in-place string reduction under tight time/space constraints, and correctness reasoning for edge cases.

    Coding & AlgorithmsOnline Assessment
  • LinkedInEasyMachine Learning Engineer
    Compute point-to-segment minimum distance

    This problem tests your ability to apply vector projections and geometric constraints to find the shortest distance from a point to a line segment in a 2D plane.

    Coding & AlgorithmsTechnical ScreenGeometryVectorsMath
  • LinkedInMediumMachine Learning Engineer
    Compute total covered interval length

    Compute total covered interval length 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
  • LinkedInMediumMachine Learning Engineer
    Find shortest word transformation with caching

    Find shortest word transformation with caching 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
  • LinkedInMediumMachine Learning Engineer
    Generate uniform 0–6 from biased coin

    This question evaluates understanding of randomized algorithms, probability theory, and techniques for extracting uniform randomness from a biased source.

    Coding & AlgorithmsOnsite
  • LinkedInMediumMachine Learning Engineer
    Implement K-Means and Explain Convergence

    This problem tests the implementation of the K-means clustering algorithm from scratch, requiring an understanding of the iterative refinement process, distance metrics, and the underlying mathematical objective.

    Coding & AlgorithmsTechnical ScreenClusteringUnsupervised LearningAlgorithms
  • LinkedInMediumMachine Learning Engineer
    Implement alert queries and spike detection

    This problem tests your ability to process a stream of events with time-based constraints, requiring an efficient sliding-window approach and the use of monotonic data structures for spike detection.

    Coding & AlgorithmsOnsiteSliding WindowData StructuresStreaming
  • LinkedInMediumMachine Learning Engineer
    Sample index from probability distribution

    This question tests the ability to implement a weighted random sampling algorithm efficiently using prefix sums and binary search to achieve sub-linear query time.

    Coding & AlgorithmsOnsiteAlgorithmsProbabilityBinary Search
  • LinkedInMediumMachine Learning Engineer
    Sample uniformly from a circle’s area

    This question evaluates understanding of continuous probability distributions and geometric random sampling, testing whether a candidate recognizes how area-weighted uniformity differs from naive radial choices.

    Coding & AlgorithmsOnsite
  • LinkedInMediumMachine Learning Engineer
    Sort the values of a quadratic function applied to a sorted array in linear time

    Given an integer array sorted in ascending order and the coefficients of a quadratic function, apply the function to every element and return the results in sorted order in linear time. Tests reasoning about the shape of a parabola, handling of positive, negative and zero leading coefficients, and duplicate values.

    Coding & AlgorithmsTechnical Screen