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 481–510 of 3640 results

  • AnthropicMediumSoftware Engineer
    Mode, Median and Sort Across 10 Nodes with Send/Receive While Minimizing Traffic

    Integers are spread across 10 nodes that communicate only by sending and receiving messages. Write the per-node programs that compute the exact mode, the median and a globally sorted order while sending as little data as possible. It tests MapReduce-style aggregation, distributed selection, sample sort and message coordination.

    Software Engineering FundamentalsOnsite
  • AnthropicHardSoftware Engineer
    Optimize a compute kernel with a simulator

    This question evaluates performance engineering and low-level kernel optimization competencies, including profiling, data-layout and instruction-level techniques, correctness verification, and benchmark-driven measurement within the System Design domain.

    System DesignOnsite
  • AnthropicMediumSoftware Engineer
    Parallelize a Directory Walker With Thread-Safe Visited Tracking

    Turn a sequential directory walker into a bounded-concurrency one, using an atomic reserve-before-expand step so two worker threads that reach the same directory at once never process it twice.

    Software Engineering FundamentalsOnsiteconcurrencythreadingshared-state
  • AnthropicMediumSoftware Engineer
    Path Resolution with Symbolic Links

    Implement a filesystem path resolution function that normalizes paths containing '.', '..', and symbolic links while detecting cycles.

    Coding & AlgorithmsOnsitestring parsingstacksimulation
  • AnthropicMediumSoftware Engineer
    Performance-Model a Sharded Matrix Multiply: FLOPs, Memory, Network and Roofline

    Model the performance of a matrix multiplication by hand: count floating-point operations, memory bytes and network bytes, apply the roofline model to decide what bounds it, and compare sharding along each dimension across several accelerators. It tests arithmetic intensity, collective communication costs and quantitative reasoning.

    ML System DesignOnsite
  • AnthropicHardSoftware Engineer
    Present a Technical Project to a Cross-Functional Audience

    Tests your ability to present a complex engineering effort to a cross-functional technical panel, balancing architectural depth, consequential trade-offs, and rigorous post-launch reflection.

    Behavioral & LeadershipOnsitebehavioralproject-deep-divecommunication
  • AnthropicMediumSoftware Engineer
    Present project and answer behaviorals

    This question evaluates leadership and behavioral competencies alongside technical communication skills, including project ownership, system architecture articulation, trade-off reasoning, metrics-driven impact measurement, stakeholder management, and mentorship.

    Behavioral & LeadershipOnsite
  • AnthropicHardSoftware Engineer
    Reason About Delaying an AI Breakthrough Under Uncertain Risk

    Reason about an AI breakthrough under uncertain risk by separating research and deployment, weighing evidence and reversibility, and addressing competitive pressure consistently.

    Behavioral & LeadershipOnsite
  • AnthropicMediumSoftware Engineer
    Repairing a Difficult Working Relationship

    Tests emotional intelligence, self-awareness, and constructive conflict resolution when collaborating with engineering peers or cross-functional partners under pressure.

    Behavioral & LeadershipOnsitebehavioralconflict-resolutioncollaboration
  • AnthropicMediumSoftware Engineer
    Resolve a Package Dependency Graph with Concurrent Fetches

    Discover a package's transitive dependency graph from a slow, flaky registry, first with a sequential BFS and then with a bounded pool of worker threads. Tests atomic visited-set reservation, explicit retry state, and correct termination detection with in-flight work.

    Software Engineering FundamentalsOnsiteconcurrencythreadinggraph-traversal
  • AnthropicMediumSoftware Engineer
    Respond to a Hypothetical Loss of Employer Equity Value

    Tests how candidates navigate extreme organizational adversity, balance personal financial realities against mission alignment, and evaluate their long-term commitment and team responsibilities during a company crisis.

    Behavioral & LeadershipOnsiteBehavioralLeadershipAdversity Management
  • AnthropicMediumSoftware Engineer
    Resume Project Deep Dive and Prioritizing Too Many Tasks at Once

    A behavioral interview question in two parts: a deep dive into a project from your resume, where the interviewer probes design decisions, your own contribution and results, and a question about a time you had more tasks than you could finish. It tests technical depth, prioritization criteria and how you communicate trade-offs to stakeholders.

    Behavioral & LeadershipOnsite
  • AnthropicMediumSoftware Engineer
    Reuse Work Across Multiprocess Image Pipelines

    Implement a thread-safe pipeline execution engine that caches deterministic intermediate prefix results, deduplicates concurrent in-flight computations, and manages a bounded LRU cache.

    Software Engineering FundamentalsOnsiteconcurrencycachingsystem-design
  • AnthropicMediumSoftware Engineer
    Review a Batched GPU Inference API Design Doc: Flaws, Throughput, Mixed-Model GPUs

    Review a design document for a batched GPU inference API and find its flaws in load balancing, batching, caching, retries and admission control. Then compare theoretical and achievable throughput at 100 ms per batch and 10,000 QPS, and schedule a large and a small model on one 8-GPU pool.

    System DesignOnsite
  • AnthropicHardSoftware Engineer
    Review an inference API design for scale

    This question tests a candidate's ability to critically evaluate ML system designs for production-scale inference APIs, covering multi-tenancy, GPU resource constraints, and streaming token delivery. It assesses architectural reasoning across reliability, latency trade-offs, and capacity planning in the ML Systems domain.

    ML System DesignOnsite
  • AnthropicHardSoftware Engineer
    Review and Improve Four AI-Assisted TypeScript Pull Requests

    Tests code review rigor, ability to audit AI-generated code for subtle regressions and security/type soundness, and hands-on refactoring with test-driven verification.

    Software Engineering FundamentalsOnsiteTypeScriptCode ReviewConcurrency
  • AnthropicMediumSoftware Engineer
    Same-Domain Web Crawl (BFS)

    Implement a breadth-first search crawler that traverses pages starting from a seed URL, filtering for pages sharing the same domain and properly deduplicating visited URLs.

    Coding & AlgorithmsOnsitebfsgraphstring-parsing
  • AnthropicMediumSoftware Engineer
    Same-Host Web Crawler: Single-Threaded, Then Concurrent with a Thread-Safe Visited Set

    Build a web crawler that starts from one URL, follows links only on the same hostname, strips URL fragments and fetches each page once, first single-threaded and then concurrently. It tests graph traversal, URL normalization, a thread-safe visited set and correct termination of concurrent work.

    Software Engineering FundamentalsOnsite
  • AnthropicMediumSoftware Engineer
    Scale a Thumbnail-and-Watermark Pipeline With Worker Processes

    Design a batch pipeline that produces a resized thumbnail with a corner watermark for every uploaded photo, then extend it to run across a bounded pool of worker processes. Tests resource lifecycle, atomic output writes, per-item failure isolation, and what to pass between processes.

    Software Engineering FundamentalsOnsitemultiprocessingsystem-designpython
  • AnthropicHardSoftware Engineer
    Schedule instructions on a VLIW pipeline

    This question evaluates proficiency in VLIW instruction scheduling, pipeline hazard analysis (RAW/WAR/WAW), register-pressure management, and software-pipelining for loop kernels within the System Design domain of computer architecture and compiler backends.

    System DesignOnsite
  • AnthropicHardSoftware Engineer
    Simulate Threshold Infection Efficiently

    Simulate a synchronous threshold-based infection process on a grid using an incremental multi-source BFS to achieve optimal linear time complexity.

    Coding & AlgorithmsOnsiteBFSGraphMatrix
  • AnthropicMediumSoftware Engineer
    Simulate stack traces from logs

    This question evaluates stack-based simulation for computing exclusive execution time in nested function call logs and stream-processing concepts for handling equal timestamps, slight reordering, and detection of N consecutive categorical events.

    Coding & AlgorithmsOnsite
  • AnthropicMediumSoftware Engineer
    System Design: Pushing a Multi-Terabyte Snapshot to Thousands of Nodes

    Figure out the theoretical floor on how fast a large search-index snapshot can reach every node in a fleet given each machine's shared upload/download bandwidth, then design a chunked, peer-assisted distribution scheme that approaches that floor and copes with stragglers and failures. Tests bandwidth reasoning and evolving a design from a naive baseline.

    System DesignOnsitesystem-designnetworkingdistributed-systems
  • AnthropicMediumSoftware Engineer
    Time-Based Key-Value Store

    Design a versioned key-value store that supports storing values at specific timestamps and retrieving the most recent value at or before a given timestamp.

    Coding & AlgorithmsOnsitebinary-searchhash-tabledesign
  • AnthropicHardSoftware Engineer
    Walk through a recent technical project

    This question evaluates a candidate's engineering depth and leadership competency by requiring a structured walkthrough of a recent technical project covering problem framing, architectural trade-offs, data modeling and APIs, scalability and reliability, testing and rollout, and measurement of outcomes.

    Behavioral & LeadershipOnsite
  • AnthropicMediumSoftware Engineer
    Why Anthropic, What AI Safety Means to You, and AI Misuse: Recruiter Screen Prep

    Prepare for a recruiter screen at an AI safety lab that spends most of its time on motivation and safety views: why you are leaving, why this lab over others, what AI safety means to you, misuse scenarios, the biggest risks and benefits of advanced AI, and an underrated problem. It tests depth, honesty and preparation.

    Behavioral & LeadershipOnsite
  • AnthropicHardSoftware Engineer
    Why Join an AI Safety-Focused Lab, and What Is Your View on AI Safety?

    A recruiter-call question for a senior software engineer at an AI lab: explain why you want to join this particular company and share your own view on AI safety. It tests whether your motivation is specific and sincere, whether you can state a reasoned, calibrated position on AI risk, and how you connect safety to engineering work.

    Behavioral & LeadershipOnsite
  • AnthropicMediumSoftware Engineer
    Word Search in a Letter Grid

    This problem tests the ability to implement a backtracking search on a 2D grid, optimized with a Trie data structure to efficiently search for multiple strings simultaneously.

    Coding & AlgorithmsOnsiteTrieBacktrackingDFS
  • AnyscaleMediumSoftware Engineer
    Design a Service That Sends a JSON Payload to a URL at a Scheduled Time

    Design a service that accepts JSON requests containing a target URL, a UTC timestamp and a payload, stores them durably, and sends each payload to its URL at the scheduled time. It tests finding due work at scale, delivery guarantees and retries, isolation from slow endpoints, outbound-request security and failure recovery.

    System DesignOnsite
  • AppleHardSoftware Engineer
    ASIC Verification Fundamentals Across SystemVerilog UVM CDC and Architecture

    Review a broad ASIC verification set covering SystemVerilog semantics, UVM lifecycle and communication, random constraints, clock-domain crossing, FIFO sizing, timing, clock division, cache coherence, and pipeline hazards. Strong responses distinguish simulation from hardware, define assumptions, derive quantities, compare trade-offs, and use precise examples.

    Software Engineering FundamentalsOnsite