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 4591–4616 of 4616 results

  • eBayEasyApplied Scientist
    Named entity recognition: framing, algorithm choice, data processing, and metrics

    A machine learning question on named entity recognition for short e-commerce text such as listing titles and search queries. It asks you to define the task, compare NER algorithm families and choose one, plan labeling and data processing, and select entity-level and product-level metrics.

    Machine LearningTechnical Screen
  • eBayEasyApplied Scientist
    Optimizing BERT inference latency and throughput for a production NLP service

    An ML engineering question on speeding up a fine-tuned BERT encoder that has become too slow or too costly to serve in production. It tests profiling, model compression, runtime and serving optimizations such as batching and padding control, and how to verify that accuracy does not regress.

    Machine LearningTechnical Screen
  • eBayMediumSoftware Engineer
    Rebuild a Binary Tree from Two Traversals and Serialize It Level by Level

    Given the preorder and inorder traversals of a binary tree with distinct values, rebuild the tree and return its level-order serialization, with empty slots marked as None and trailing ones removed. It tests understanding of traversal orders, careful index bookkeeping and an efficient solution for trees with thousands of nodes, including fully skewed ones.

    Coding & AlgorithmsTechnical Screen
  • eBayMediumSoftware Engineer
    Return the K Smallest Values from Sorted Arrays

    Tests ability to efficiently merge multiple sorted streams to extract the k smallest elements using a min-heap or frontier-based approach. Evaluates handling of empty arrays, duplicates, and computational complexity dependent on the number of arrays rather than total elements.

    Coding & AlgorithmsTechnical ScreenHeapPriority QueueMerge Sort
  • eBayMediumSoftware Engineer
    Search a Rotated Sorted Array in One Binary-Search Pass

    Implement a single-pass binary search to locate a target value in a rotated strictly increasing array in logarithmic time and constant auxiliary space.

    Coding & AlgorithmsTechnical Screenbinary-searcharraysdivide-and-conquer
  • eBayMediumSoftware Engineer
    Wildcard Dictionary Matching

    This problem tests your ability to implement a pattern-matching algorithm that supports variable-length wildcards using recursion with memoization or dynamic programming.

    Coding & AlgorithmsTechnical ScreenRecursionDynamic ProgrammingString Matching
  • xAIMediumData Engineer
    Build a One-Pass Data Cleaning Pipeline

    This problem tests your ability to design a memory-efficient, scalable data streaming pipeline that processes raw web-scraped documents into a high-quality dataset for model pretraining.

    System DesignTechnical ScreenData EngineeringStreamingData Cleaning
  • xAIMediumSoftware Engineer
    Compute dasher pay from order events

    This question evaluates a candidate's ability to process time-based event streams, manage overlapping active intervals, and compute aggregate payouts under concurrency constraints.

    Coding & AlgorithmsTechnical Screen
  • xAIMediumSoftware Engineer
    Contrast processes and threads

    This question evaluates understanding of operating system and concurrency fundamentals—specifically differences between processes and threads including memory isolation, resource ownership, scheduling, context-switch costs, inter-process communication versus in-process synchronization, failure isolation, and security.

    Coding & AlgorithmsTechnical Screen
  • xAIMediumMachine Learning Engineer
    Describe your research and contributions

    Describe your research and contributions evaluates behavioral evidence, ownership, communication, trade-offs, and measurable outcomes in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Behavioral & LeadershipTechnical Screen
  • xAIMediumMachine Learning Engineer
    Design O(1) random-sampling set

    This question evaluates a candidate's competency in data-structure design, randomized algorithms, and algorithmic complexity analysis within the Coding & Algorithms domain, with a focus on achieving expected O(1) operations for insert, remove, and uniform sampling.

    Coding & AlgorithmsTechnical Screen
  • xAIMediumSoftware Engineer
    Design a Durable Key-Value Cache with File-System Persistence

    This question evaluates a candidate's ability to design durable in-memory data structures and persistence strategies, including reasoning about crash recovery, durability guarantees, and performance trade-offs.

    System DesignTechnical Screen
  • xAIMediumSoftware Engineer
    Design a Recoverable Iterator

    Design a forward-only iterator wrapper that supports saving and restoring cursor state via checkpoints, testing buffering strategies and memory management.

    Coding & AlgorithmsTechnical Screendesigndata-structuresiterators
  • xAIHardMachine Learning Engineer
    Design a house-price prediction workflow

    Design a house-price prediction workflow evaluates core ML concepts, assumptions, math intuition, training/evaluation trade-offs, and practical failure modes in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Machine LearningTechnical Screen
  • xAIEasySoftware Engineer
    Design a multi-level API rate limiter

    This question assesses the ability to design a scalable, multi-tenant rate limiting service that supports hierarchical policies and global traffic coordination.

    System DesignTechnical ScreenDistributed SystemsScalabilityCaching
  • xAIMediumSoftware Engineer
    Explain and Implement Strings

    This question evaluates understanding of string data structures, memory layout, ownership and move semantics in Rust, and algorithmic complexity related to copying and performance.

    Coding & AlgorithmsTechnical Screen
  • xAIMediumSoftware Engineer
    Explain arrays and memory layout

    This question evaluates understanding of arrays, their contiguous memory representation including element size, alignment and indexing arithmetic, along with time-complexity analysis for access, insertion and deletion and implications for cache locality.

    Coding & AlgorithmsTechnical Screen
  • xAIMediumSoftware Engineer
    Explain process vs thread and memory-sharing risks

    This question tests the conceptual understanding of process versus thread architecture and the synchronization challenges inherent in shared-memory multithreading.

    Software Engineering FundamentalsTechnical ScreenOperating SystemsConcurrencyMultithreading
  • xAIMediumSoftware Engineer
    Explain strings, moves, and concurrency

    This question evaluates understanding of string data structures, ownership and move semantics (including Rust-specific move behavior), and concurrency models such as threads versus asynchronous coroutines, testing competencies in memory management, performance analysis, and concurrent programming.

    Coding & AlgorithmsTechnical Screen
  • xAIHardSoftware Engineer
    Find kth element and sliding-window kth in stream

    This problem tests your ability to maintain order statistics in a streaming context, moving from a static selection problem to an efficient sliding-window implementation.

    Coding & AlgorithmsTechnical ScreenQuickSelectHeapSliding Window
  • xAIMediumSoftware Engineer
    Flatten and unflatten nested Python structures

    This problem tests recursion, type introspection, and data structure manipulation by requiring the implementation of flattening and reconstruction logic for arbitrarily nested lists and dictionaries.

    Coding & AlgorithmsTechnical ScreenRecursionData StructuresSerialization
  • xAIHardMachine Learning Engineer
    Implement Distributed Matrix Multiplication

    This problem tests your ability to design a distributed matrix multiplication algorithm by partitioning large matrices across multiple worker nodes to minimize communication overhead.

    Coding & AlgorithmsTechnical ScreenDistributed SystemsLinear AlgebraParallel Computing
  • xAIMediumSoftware Engineer
    Implement a Radix Cache for Integer Sequences

    This question evaluates understanding of radix trees (prefix-compressed tries), sequence-oriented trie manipulation, and the maintenance of invariants like distinct branching and maximal compression, and belongs to the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • xAIHardMachine Learning Engineer
    Implement a trie-based tokenizer

    This question evaluates a candidate's competency in designing and implementing a production-grade subword tokenizer, covering trie-based longest-prefix matching, Unicode-aware text processing, normalization and casing impacts, whitespace/punctuation rules, fallback strategies, performance and memory trade-offs, versioning, and testing for edge cases. It is commonly asked in ML System Design interviews to assess practical implementation skills and conceptual trade-off reasoning for deterministic, scalable LLM preprocessing, and tests both practical application and conceptual understanding within the ML System Design domain.

    ML System DesignTechnical Screen
  • xAIMediumData Engineer
    Implement two string utility functions

    This question evaluates proficiency in string manipulation and text processing, including character counting, tokenization by spaces, case-sensitive comparisons, and preserving original word order.

    Coding & AlgorithmsTechnical Screen
  • xAIHardSoftware Engineer
    Maximize distinct values after unique ± offsets

    This problem tests greedy strategy and sorting to determine the maximum possible count of distinct values in an array after applying exactly one offset from a given set of allowed integers to each element.

    Coding & AlgorithmsTechnical ScreenGreedySortingCombinatorics