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

  • DatabricksHardSoftware Engineer
    Find shortest path in a Fibonacci-ordered tree

    This question evaluates understanding of recursive binary tree structures, preorder indexing, Fibonacci-like size relations, and arithmetic-based navigation for computing paths in an implicitly defined tree.

    Coding & AlgorithmsTechnical Screen
  • DatabricksEasyData Scientist
    Find top-5 most similar rows across datasets

    This question evaluates understanding and implementation of similarity/distance metrics (e.g., MSE), data preprocessing issues such as handling NULLs and feature scaling, and the ability to perform efficient cross-dataset comparisons and top-k ranking.

    Data Manipulation (SQL/Python)Technical Screen
  • DatabricksHardSoftware Engineer
    Identify and handle race conditions

    This question evaluates understanding of concurrency, race conditions, synchronization mechanisms, and performance trade-offs in designing thread-safe in-memory data structures like key-value stores and hit counters.

    System DesignTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement CIDR firewall matcher

    This interview question evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer for Implement CIDR firewall matcher states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement Snapshot Iterator Without Order Guarantees

    This question evaluates data-structure design and iterator semantics—specifically snapshot iteration over a mutable, set-like collection without order guarantees—and tests skills in implementing mutation-isolated iteration and analyzing time and space complexity; it belongs to the Coding & Algorithms domain and emphasizes practical implementation.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Implement a Snapshot Set Iterator

    This question evaluates understanding of set data structures, iterator and snapshot semantics, and the ability to reason about time and space complexity when providing stable views over mutable collections.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Implement a sliding-window hit counter

    This question evaluates understanding of time-based data structures and algorithms for sliding-window counters, including fixed-size array bucketing, handling timestamp collisions within buckets, refactoring for reuse, and time/space complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Implement an Alternating Tic-Tac-Toe Game

    This problem tests your ability to design a robust state machine for a board game, focusing on efficient win-condition checking and clean API design.

    Coding & AlgorithmsTechnical ScreenState ManagementArraysGame Theory
  • DatabricksMediumSoftware Engineer
    Optimal Commute: Nearest Transit Distance in a City Grid

    Tests the ability to solve multi-source shortest path problems on a grid using multi-source Breadth-First Search (BFS). Evaluates graph traversal efficiency, boundary checking, and handling of impassable terrain.

    Coding & AlgorithmsTechnical ScreenBreadth-First SearchMatrixGraph
  • DatabricksHardSoftware Engineer
    Optimize a SQL query plan tree

    This problem tests your ability to manipulate an Abstract Syntax Tree (AST) representing a relational query plan to reduce data processing costs through predicate pushdown and projection pruning.

    Coding & AlgorithmsTechnical ScreenTreesRecursionDatabase Internals
  • DatabricksEasyData Scientist
    Relate coefficients under linear feature transformation

    This question tests the relationship between regression coefficients when predictors undergo linear transformations, specifically focusing on scaling and centering transformations.

    Statistics & MathTechnical ScreenLinear RegressionLinear AlgebraFeature Engineering
  • DatabricksMediumSoftware Engineer
    Solve Grid Path and Graph Sampling

    This question tests the ability to solve a shortest-path problem with multiple constraints using Dijkstra's algorithm, followed by understanding sampling techniques for connected graph structures.

    Coding & AlgorithmsTechnical ScreenDijkstraGraph AlgorithmsDynamic Programming
  • DatabricksHardData Scientist
    Test coin fairness from 560 tails in 1000 flips

    This problem evaluates hypothesis testing for proportions—formulating null and alternative hypotheses, applying the binomial-to-normal approximation, and interpreting p-values; it belongs to Statistics & Math for Data Scientist roles and is pitched at an introductory/undergraduate applied statistics level.

    Statistics & MathTechnical Screen
  • DatadogMediumSoftware Engineer
    Build span trees from unordered trace spans

    This problem tests your ability to reconstruct a parent-child hierarchical tree from an unordered collection of trace spans by leveraging parent ID references and sorting mechanisms.

    Coding & AlgorithmsTechnical ScreenTreesHash MapsSorting
  • DatadogMediumSoftware Engineer
    Deep-dive a recent project

    This question evaluates project ownership, technical leadership, system architecture, trade-off reasoning, and the ability to articulate goals, constraints, decisions, metrics and postmortem lessons in a software engineering context.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Describe handling conciseness feedback

    This question evaluates a candidate's ability to accept and act on conciseness feedback, encompassing communication clarity, adaptability, measurement of improvement, and leadership influence on stakeholder interactions.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Design an LLM Agent System That Automatically Resolves Jira Tickets and Opens Pull Requests

    Design an autonomous agent pipeline that ingests Jira bug reports, grounds itself in a multi-repo codebase via code search and retrieval, iterates on a fix in a sandboxed runtime, and opens a validated pull request.

    ML System DesignTechnical ScreenLLM AgentsCode GenerationRAG
  • DatadogHardSoftware Engineer
    Design an image detection system

    This question evaluates a candidate's competence in designing scalable, reliable end-to-end machine learning systems for image object detection, including ingestion, preprocessing, model serving, data and version management, monitoring, and operational concerns.

    ML System DesignTechnical Screen
  • DatadogHardSoftware Engineer
    Design log-query stream processor

    Design log-query stream processor evaluates requirements, scale assumptions, API/data design, architecture, trade-offs, failure modes, and rollout in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    System DesignTechnical Screen
  • DatadogMediumSoftware Engineer
    Explain a project concisely and deeply

    This question evaluates project leadership, technical ownership, stakeholder communication, decision‑making under trade‑offs, and the ability to quantify measurable impact through a concise overview followed by a deep dive.

    Behavioral & LeadershipTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement DeleteTree With Limited Filesystem APIs

    Implement a robust recursive tree-deletion algorithm using a restricted set of filesystem primitives. This question tests post-order traversal, managing call-stack and heap memory across deep and wide directory structures, and handling edge cases cleanly.

    Software Engineering FundamentalsTechnical Screentreestackdfs
  • DatadogHardMachine Learning Engineer
    Implement Focal Loss for Class-Imbalanced Classification

    Tests the ability to implement binary focal loss with raw logits from first principles, emphasizing numerical stability, custom weighting, and tensor reduction strategies.

    Machine LearningTechnical Screenmachine-learningdeep-learningpytorch
  • DatadogHardMachine Learning Engineer
    Implement Grouped-Query Attention (GQA)

    Implement the Grouped-Query Attention (GQA) mechanism commonly used in modern LLMs to balance serving memory bandwidth with generation quality. You will handle tensor reshaping/expansion across query head groups, scaled dot-product attention, and causal masking.

    Machine LearningTechnical Screendeep-learningtransformerspytorch
  • DatadogEasySoftware Engineer
    Implement buffered file writer with concurrency support

    This question evaluates a candidate's ability to implement buffered I/O and design concurrency-safe APIs, exercising skills in data buffering, performance optimization, and thread-safety.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement log storage and querying

    This question evaluates a candidate's skill in designing and analyzing log storage and query systems, covering data layout, indexing strategies, time-range scans with optional filters, and time/space complexity reasoning.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Implement write with internal buffer

    This question evaluates proficiency with buffered I/O, buffer management, memory handling, and performance optimization, including maintaining byte order, handling partial writes, and edge cases across consecutive write/flush/close operations.

    Coding & AlgorithmsTechnical Screen
  • DatadogMediumSoftware Engineer
    Match logs to prior queries

    This question evaluates understanding of streaming algorithms, string indexing, and set-based matching, focusing on designing efficient online data structures to match stored queries against incoming logs within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • DatologyaiHardSoftware Engineer
    Cursor-Based Text Editor: Typing, Backspace, and Four-Way Cursor Movement

    Implement a TextEditor class with a single cursor that supports typing a character, backspace, and rendering the text with a | at the cursor, then extend it with left/right and up/down cursor movement. Tests choice of representation, per-operation cost, and boundary handling across lines of different lengths.

    Software Engineering FundamentalsTechnical Screen
  • DatologyaiEasySoftware Engineer
    Text Editor with a Cursor: Typing, Backspace, and Four-Way Cursor Movement

    Implement a text editor class that types characters at a cursor, deletes with backspace, and renders the text with a bar marking the cursor. Follow-ups add left/right and then up/down cursor movement, testing the choice of data structure for cheap edits, boundary handling, and line-aware navigation.

    Software Engineering FundamentalsTechnical Screen
  • DatologyaiEasySoftware Engineer
    Word Count and Multiset Intersect Using Only a Mock Spark RDD API

    Given a minimal mock of a Spark RDD with only flatMap, groupByKey, union and collect, implement a word count function and a duplicate-preserving intersect of two RDDs. Tests composing transformations without map or reduce, tracking which input an item came from, and reasoning about the cost of grouping.

    Software Engineering FundamentalsTechnical Screen