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

  • Jane StreetHardSoftware Engineer
    Snake Game: Minimum Moves to Reach the Apple

    This question evaluates proficiency in state-space modeling, constrained grid pathfinding, and dynamic collision handling, testing skills in shortest-path reasoning and movement legality within the Coding & Algorithms domain; the level of abstraction is practical application of algorithmic techniques to simulate evolving game states rather than purely theoretical analysis. It is commonly asked in technical interviews because it requires reasoning about evolving constraints and reachable states, demonstrating an applicant's ability to model complex movement rules and perform effective search under limited grid and body-size constraints.

    Coding & AlgorithmsTechnical Screen
  • Jane StreetEasyQuantitative Trader
    Solve probability and game-theory puzzles

    This set of puzzles evaluates probabilistic reasoning, Bayesian inference, expected-value optimization, optimal stopping, and strategic game-theoretic reasoning under uncertainty and asymmetric information, situated in the Statistics & Math domain.

    Statistics & MathTechnical Screen
  • Jane StreetEasySoftware Engineer
    Stack Machine Interpreter with Typed Int and String Values

    This question evaluates understanding of stack-machine semantics, runtime type representation and preservation of distinct integer versus string values, plus handling mixed-type ADD behavior and output semantics.

    Coding & AlgorithmsTechnical Screen
  • Jane StreetMediumSoftware Engineer
    Turning Interview Code into a Reusable Library or API

    This question evaluates a candidate's skills in software design and engineering practices, including modularization, API and library interface design, documentation and typing, robustness and error handling, testing, packaging, versioning, and state/transport considerations.

    Software Engineering FundamentalsTechnical Screen
  • Jane StreetMediumSoftware Engineer
    Write an Interpreter for a Small Language with Load, Store and Arithmetic

    Practice writing an interpreter for a small language with load, store and integer arithmetic instructions, using an assumed stack-based specification. It tests parsing source text into instructions, executing them with correct operand order, and reporting errors such as stack underflow, undefined variables and division by zero.

    Software Engineering FundamentalsTechnical Screen
  • JefferiesEasyData Scientist
    How to compute correlation from variances

    Practice deriving correlation from variance identities for two random variables. The solution explains why Var(X+Y) and Var(X) alone are insufficient, derives covariance and correlation when Var(Y) is known, simplifies the equal-variance case, and checks edge cases where correlation is invalid or inconsistent.

    Statistics & MathTechnical Screen
  • JefferiesMediumData Scientist
    How to derive correlation from variances

    Evaluates derivation of correlation from variance identities for two random variables. Strong answers explain why Var(X+Y) and Var(X) alone do not identify correlation, then derive covariance and correlation when Var(Y) is also known.

    Statistics & MathTechnical Screen
  • Jump TradingHardSoftware Engineer
    Accelerate Tree-Model Inference

    Design an end-to-end strategy to accelerate inference latency and throughput for an existing gradient-boosted decision tree (GBDT) model in a low-latency trading environment while preserving exact prediction fidelity. Address feature engineering constraints, low-level execution optimizations, verification of numerical equivalence, and production drift monitoring.

    Machine LearningTechnical ScreenTree ModelsInference OptimizationLow-Latency Systems
  • Jump TradingEasySoftware Engineer
    Design Stack Evaluators and Low-Latency Memory Primitives

    This question tests your understanding of low-latency systems programming, focusing on thread-safe memory management, cache locality, and efficient expression parsing.

    Software Engineering FundamentalsTechnical ScreenC++ConcurrencyLow-Latency
  • Jump TradingHardSoftware Engineer
    Design a Compact Columnar File Format

    Design an append-friendly, compact columnar file format optimized for fast analytical scans over tabular financial market data (e.g., tick feeds or order book snapshots). Define the on-disk binary layout, reader/writer abstractions, serialization rules, and operational trade-offs.

    Software Engineering FundamentalsTechnical Screensystems-designfile-formatscolumnar-storage
  • Jump TradingMediumSoftware Engineer
    Explain C++ vector, unordered_map, and virtual functions

    Explain C++ vector, unordered_map, and virtual functions 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
  • Jump TradingEasySoftware Engineer
    Find the Largest Equivalence Class of Fractions

    This problem tests your ability to handle numerical equivalence using canonical representations to avoid floating-point precision issues.

    Statistics & MathTechnical ScreenMathHash MapNumber Theory
  • Jump TradingEasySoftware Engineer
    Largest Subset With Positive Bitwise AND

    This problem tests your understanding of bitwise operations and greedy array partitioning to maximize the size of a subset that results in a non-zero bitwise AND.

    Coding & AlgorithmsTechnical ScreenBit ManipulationGreedyArrays
  • KaratMediumSoftware Engineer
    Join tables to map userId to name

    This question evaluates a candidate's skills in relational data joining, data integration, and numeric reconciliation for mapping userId to customerName across multiple tables.

    Coding & AlgorithmsTechnical Screen
  • KaratMediumSoftware Engineer
    Validate password and list rule violations

    This question evaluates string-processing and input-validation skills, including case-insensitive substring detection, character class checks, pattern matching for special symbols, and handling edge cases like consecutive character limits.

    Coding & AlgorithmsTechnical Screen
  • KikoffEasySoftware Engineer
    Build a Robust Log Parser and Prefix-Operator Search

    Implement a log parser and query engine that converts raw server log lines into structured records and supports filtering via prefix-operator tokens.

    Software Engineering FundamentalsTechnical ScreenString ParsingData StructuresSoftware Architecture
  • KikoffMediumSoftware Engineer
    Parse CSV and format transactions

    This question evaluates a candidate's ability to parse and format structured transactional data, emphasizing CSV parsing, trimming whitespace, numeric formatting to two decimal places, and preserving input row order.

    Data Manipulation (SQL/Python)Technical Screen
  • KikoffEasySoftware Engineer
    Validate a Third-Party Identity Payload

    Implement a pipeline that validates a third-party identity verification response against schema requirements and business rules while returning sanitized failure reason codes.

    Software Engineering FundamentalsTechnical ScreenData ValidationPythonClean Code
  • LabelboxMediumData Scientist
    Explain Google ADK and Compare with LangChain, AWS Bedrock

    This interview question evaluates behavioral evidence, ownership, communication, trade-offs, and measurable outcomes in a realistic interview setting. A strong answer for Explain Google ADK and Compare with LangChain, AWS Bedrock states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Behavioral & LeadershipTechnical Screen
  • LatentHardSoftware Engineer
    Add Status, Pharmacist Worklists, and Digests to Prior Authorization

    Design an event-driven prior authorization platform supporting real-time status tracking, prioritized pharmacist worklists, and scheduled email digests powered by asynchronous payer integrations.

    System DesignTechnical ScreenEvent-DrivenHealthcareDistributed Systems
  • LayerzeroMediumSoftware Engineer
    Choose a Safe Polling Strategy for Delayed Records

    Evaluate whether delayed arrivals can support a fixed polling interval that always yields exactly one new record. Use worst-case reasoning, then define a practical live contract covering observation limits, warm-up, buffering, cursors, deduplication, retries, out-of-order data, and multiple pollers.

    Software Engineering FundamentalsTechnical Screen
  • Lead BankMediumSoftware Engineer
    Implement Stock Price Query APIs

    This question evaluates skills in time-series data modeling, API and data-structure design, transactional (atomic) batch updates, concurrency control, and date/time parsing for stock price records.

    Coding & AlgorithmsTechnical Screen
  • Lead BankMediumSoftware Engineer
    Implement a versioned hash map with snapshot

    This question evaluates understanding of versioned hash maps, time-travel key-value stores, temporal retrieval semantics, and snapshot creation, testing algorithms and data-structure design in the Coding & Algorithms domain and emphasizing practical implementation with conceptual reasoning about correctness and timestamp semantics.

    Coding & AlgorithmsTechnical Screen
  • LeagueMediumSoftware Engineer
    Design scalable insurance claims processing system

    Walks through designing a scalable insurance claims processing system: ingestion, validation, routing, and the reliability and consistency trade-offs. Includes a worked system design solution.

    System DesignTechnical Screen
  • LegoraMediumSoftware Engineer
    Senior engineer project deep dive: trade-offs, scale, challenges, hardest part

    Behavioral question for senior software engineers: lead a 20-minute deep dive into a past project and answer probing questions about trade-offs, operating scale, challenges and the hardest part. It assesses ownership, engineering judgment, use of concrete numbers, and clear technical communication under time pressure.

    Behavioral & LeadershipTechnical Screen
  • LendingClubMediumData Scientist
    Determine If Two Numbers Sum to Target

    This question evaluates a candidate's basic algorithmic fluency in array processing and the ability to reason about pairwise sums using auxiliary data structures.

    Coding & AlgorithmsTechnical Screen
  • LendingClubMediumData Scientist
    Query Active Loans by Borrower ID in SQL

    This question evaluates proficiency with SQL data aggregation, grouping, and ordering to compute borrower-level loan totals, assessing practical skills in relational data manipulation within the Data Manipulation (SQL/Python) domain.

    Data Manipulation (SQL/Python)Technical Screen
  • LiftoffMediumSoftware Engineer
    Implement minimal RLE encode/decode with max run K

    This question evaluates proficiency in string parsing and compression techniques, specifically run-length encoding/decoding, pattern detection, and algorithmic optimization for producing minimal-length encodings under a maximum pattern length constraint.

    Coding & AlgorithmsTechnical Screen
  • LimeEasySoftware Engineer
    Combine Overlapping Closed Intervals Into a Sorted Disjoint List

    Given an unordered list of closed integer intervals, possibly with duplicates, nested intervals and touching endpoints, combine every chain of overlapping intervals and return the disjoint result ordered by start. It tests interval reasoning, precise overlap rules at shared endpoints, and careful handling of edge cases.

    Coding & AlgorithmsTechnical Screen
  • LinkedInHardData Scientist
    Analyze homepage drop and feed ranking

    This question evaluates a candidate's competency in product analytics, causal diagnosis, instrumentation and logging validation, segmentation and cohort analysis, and experimental design for feed ranking and user-path behavior.

    Analytics & ExperimentationTechnical Screen