Katkat

practice a little every day, paws crossed ♡

Software 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 1621–1650 of 2810 results

  • Mistral AIMediumSoftware Engineer
    Set up a Python LLM dev environment

    This question evaluates practical competencies in Python development environment setup, reproducible dependency management with lockfiles, virtual environment and interpreter management, secrets handling via environment variables, project structuring, and basic API integration.

    Software Engineering FundamentalsTechnical Screen
  • MixpanelMediumSoftware Engineer
    Group Events by an Ordered Attribute List

    This problem tests recursive data structuring and hierarchical aggregation by mapping flat event logs to a nested tree of counts based on an ordered list of attributes.

    Coding & AlgorithmsTechnical ScreenHash MapsRecursionData Aggregation
  • MixpanelMediumSoftware Engineer
    Implement precise string-based decimal addition

    This question evaluates a candidate's proficiency in string-based arbitrary-precision arithmetic, including decimal alignment, fractional carry propagation, normalization of numeric strings, and analysis of time and space complexity.

    Coding & AlgorithmsTechnical Screen
  • ModalMediumSoftware Engineer
    Explain and Harden Two Shell Commands

    Tests deep understanding of Unix shell semantics, process management, file permissions, and standard stream handling by diagnosing subtle failure modes in common shell one-liners and writing robust, production-grade replacements.

    Software Engineering FundamentalsTechnical Screenbashlinuxsystems
  • ModalMediumSoftware Engineer
    Prove an Incremental Shuffle Is Uniform

    Tests formal inductive reasoning on randomized algorithms by proving the uniformity of the Fisher-Yates shuffle, and evaluates practical knowledge of common implementation pitfalls like off-by-one bounds and modulo bias.

    Software Engineering FundamentalsTechnical Screenalgorithmsprobabilityfisher-yates
  • ModalMediumSoftware Engineer
    Sort One Hundred Million Digits

    Implement counting sort to order 100,000,000 single-digit integers using O(1) auxiliary space, and analyze performance from a hardware and memory-bandwidth perspective.

    Software Engineering FundamentalsTechnical Screenalgorithmscounting-sortsystems
  • ModularHardSoftware Engineer
    Find the Critical Path

    This question evaluates competency in graph algorithms and project scheduling, specifically reasoning about directed acyclic graphs, task dependencies, and accumulation of task durations to identify a critical path.

    Coding & AlgorithmsTechnical Screen
  • MolocoMediumSoftware Engineer
    Can you visit all rooms and score parentheses?

    The first problem evaluates graph traversal and reachability by modeling rooms and keys as an implicit graph, and it is commonly asked to assess reasoning about connectivity and exploration in graph-theoretic settings; this falls under the algorithms/graph theory domain and emphasizes practical application of traversal techniques.

    Coding & AlgorithmsTechnical Screen
  • MolocoHardSoftware Engineer
    Compute subarray span for each element

    This question evaluates array reasoning and competency in determining span-like influence regions under maximum-value constraints for each element, including handling circular-array extensions and scalability considerations.

    Coding & AlgorithmsTechnical Screen
  • MongoDBHardSoftware Engineer
    Build an Exactly-Once Crawler and Add Safe Concurrency

    Build a crawler around a supplied fetch-and-parse API, then add bounded concurrency, atomic discovery, correct completion detection, and explicit failure semantics.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Design iterator for sorted union

    This problem tests your ability to design an iterator that merges multiple sorted streams of integers while performing on-the-fly deduplication using minimal extra memory.

    Coding & AlgorithmsTechnical ScreenHeapIteratorsMerge Sort
  • MongoDBMediumSoftware Engineer
    Evaluate a Nested Predicate Expression Tree

    Implement an evaluator for a serialized predicate expression tree against JSON documents, testing recursion, AST handling, and field resolution.

    Software Engineering FundamentalsTechnical Screenrecursiontreesdesign
  • MongoDBMediumSoftware Engineer
    Implement a Lazy Union Iterator Over Two Strictly Sorted Iterators

    Implement a UnionIterator that lazily merges two strictly sorted iterators of integers or strings into one strictly sorted iterator without duplicates, using constant extra memory. Tests iterator protocol design, one-element lookahead, cross-input deduplication, end-of-stream behavior and edge cases such as empty inputs.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Implement a sliding-window rate limiter (n requests per k seconds), then make it per key

    Coding and design question from a technical screen: implement a rate limiter that admits at most n requests in any k-second sliding window, then make it thread-safe and key-specific. It tests window boundary semantics, amortized complexity, race conditions and locking, per-key state creation and memory bounds.

    Software Engineering FundamentalsTechnical Screen
  • MongoDBMediumSoftware Engineer
    Reason About Recursive Key Search in Nested JSON

    Implement a recursive search function to extract all values associated with a given key from deeply nested JSON documents containing arbitrary combinations of dictionaries and lists.

    Software Engineering FundamentalsTechnical ScreenRecursionJSONTree Traversal
  • MongoDBMediumSoftware Engineer
    Summarize background, challenge project, and failure

    This prompt evaluates leadership, technical ownership, communication, system-design reasoning, and incident-analysis competencies by requesting a concise career narrative, a deep-dive into a challenging project (including constraints, trade-offs, architecture, validation, and metrics), and a meaningful failure retrospective.

    Behavioral & LeadershipTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Clarify and Design a Streaming Top-K Tracker

    This question tests the ability to design an efficient data structure for maintaining the top-K elements in a high-throughput stream with time-windowing requirements.

    Software Engineering FundamentalsTechnical ScreenData StructuresAlgorithmsStreaming
  • NVIDIAMediumSoftware Engineer
    Compare deep learning framework trends

    Compare deep learning framework trends 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
  • NVIDIAEasySoftware Engineer
    Compute the Final Robot Score

    Tests proficiency in using priority queues (heaps) to manage dynamic multisets under iterative reductions. Evaluates the ability to simulate priority-based selection and reason about time and space complexity.

    Coding & AlgorithmsTechnical ScreenHeapPriority QueueSimulation
  • NVIDIAMediumSoftware Engineer
    Construct tree from inorder & postorder

    This question evaluates understanding of binary tree reconstruction and traversal order relationships, specifically the ability to derive tree structure from inorder and postorder arrays and implement the corresponding algorithm.

    Coding & AlgorithmsTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Count Distinct Strings With a Hand-Built Hash Table, Then Parallelize It for GPUs

    A coding and concurrency question: count the distinct strings in an array with a hash table built from scratch, then keep the count correct when many threads insert at once. It tests hash table design, locks versus atomic compare-and-swap, and how work division and memory layout affect GPU and CPU performance for a million keys.

    Software Engineering FundamentalsTechnical Screen
  • NVIDIAHardSoftware Engineer
    Count Substrings with No Repeated Characters

    Tests sliding window / two-pointer techniques to count all valid substrings without duplicate characters in linear time.

    Coding & AlgorithmsTechnical Screensliding-windowtwo-pointersstrings
  • NVIDIAMediumSoftware Engineer
    Define developer-centric usability metrics

    This question evaluates proficiency in analytics and experimentation and the ability to define and operationalize developer-centric usability metrics for both consumer-facing applications and developer tools.

    Analytics & ExperimentationTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Derive MLP shapes and explain PyTorch broadcasting

    This question tests the ability to calculate matrix transformation dimensions in a Multilayer Perceptron (MLP) and explains the rules governing PyTorch broadcasting when performing operations between tensors of different shapes.

    Machine LearningTechnical ScreenPyTorchLinear AlgebraTensors
  • NVIDIAMediumSoftware Engineer
    Describe model-to-GPU execution pipeline

    Describe model-to-GPU execution pipeline evaluates ML product requirements, data/labeling, modeling, serving architecture, evaluation, monitoring, and trade-offs in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    ML System DesignTechnical Screen
  • NVIDIAHardSoftware Engineer
    Design a Multi-Producer Multi-Consumer Circular Buffer

    Design a thread-safe, bounded multi-producer multi-consumer (MPMC) circular buffer supporting blocking operations, timeouts, and graceful shutdown (close-and-drain).

    Software Engineering FundamentalsTechnical ScreenConcurrencyData StructuresMultithreading
  • NVIDIAHardSoftware Engineer
    Design a distributed multi-user counter

    This question evaluates expertise in distributed systems architecture, concurrency control, strong consistency models, idempotency under retries, fault tolerance, leader election, and operational monitoring for high-throughput services.

    System DesignTechnical Screen
  • NVIDIAMediumSoftware Engineer
    Design a top-build target tracker

    This problem tests object-oriented design and data structure proficiency by requiring the implementation of a tracker that maintains the top-K most frequent entities within a sliding time window of events.

    Software Engineering FundamentalsTechnical ScreenDesignData StructuresSliding Window
  • NVIDIAMediumSoftware Engineer
    Design an Autonomous-Vehicle Perception Pipeline

    Tests system design principles for real-time, safety-critical autonomous vehicle perception, focusing on multi-sensor hardware synchronization, zero-copy memory pipelines, bounded-latency neural inference, and fail-operational degradation.

    System DesignTechnical ScreenAutonomous VehiclesComputer VisionReal-Time Systems
  • NVIDIAHardSoftware Engineer
    Design an artifact store on K8s and Cassandra

    This question evaluates distributed-systems and system-design competencies, including concurrency control for unique-name creation, idempotency and retry semantics, deletion modeling (soft deletes, tombstones, TTL), and read-path consistency, caching and performance when running a Java API on Kubernetes with Cassandra storage.

    System DesignTechnical Screen