Katkat

practice a little every day, paws crossed ♡

Software Engineering Fundamentals 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 211–240 of 625 results

  • GleanMediumSoftware Engineer
    How Would You Test a System That Counts the Leaves on a Tree?

    This problem evaluates your ability to design a comprehensive testing strategy for an ambiguous, real-world system where an exact 'ground truth' is difficult to obtain.

    Software Engineering FundamentalsTechnical ScreenSoftware TestingQA StrategyComputer Vision
  • GleanMediumSoftware Engineer
    Implement 2048-Style Tile Slides and Merges for All Four Board Directions

    A software engineer phone-screen coding exercise: implement the slide-and-merge move of a 2048-style tile board, first to the left with working tests, then for all four directions. It tests careful array manipulation, the single-merge rule, and the trade-off between rotating the board and remapping row and column indices.

    Software Engineering FundamentalsTechnical Screen
  • GleanMediumSoftware Engineer
    Robust Selenium Code to Extract Text from Two Elements

    This problem tests your ability to write robust browser automation code using Selenium, focusing on handling dynamic content, timing issues, and basic error handling.

    Software Engineering FundamentalsTechnical ScreenSeleniumTest AutomationPython
  • GofundmeEasySoftware Engineer
    Explain React and Firebase data interaction

    This question tests your understanding of data synchronization patterns between a React frontend and Firebase, specifically focusing on the trade-offs between real-time listeners and manual data fetching.

    Software Engineering FundamentalsTechnical ScreenReactFirebaseFrontend
  • GoogleMediumSoftware Engineer
    Build a ChatOps Command Dispatcher That Matches Named Arguments

    Implement a command dispatcher for a chat ops bot that resolves slash-separated commands with named arguments to a registered handler. Tests trie-based matching, precedence between literal and parameter segments, and handling of ambiguous or dead-end routes.

    Software Engineering FundamentalsTechnical Screentriedata-structuresapi-design
  • GoogleMediumSoftware Engineer
    Build a Custom CompletableFuture: Async Primitive and Parallel Array Processing

    Implement a thread-safe asynchronous promise/future primitive with chaining and an aggregate fan-in barrier (`all_of`) for parallel processing.

    Software Engineering FundamentalsTechnical Screenconcurrencymultithreadingdesign-pattern
  • GoogleMediumSoftware Engineer
    Design Interval Membership Queries with Linear, Logarithmic, and Constant-Time Options

    Design interval membership with linear scans, predecessor binary search, or bounded-universe direct addressing, comparing insertion, memory, adjacency, inclusive boundaries, overflow safety, and workload fit.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Design a waitlist system with top/bottom K

    This problem tests your ability to design a dynamic waitlist using efficient data structures to support logarithmic time complexity for insertions, deletions, and ranking operations.

    Software Engineering FundamentalsTechnical ScreenData StructuresDesignComplexity Analysis
  • GoogleMediumSoftware Engineer
    Evolve Duplicate Detection for Sliding Windows and Read-Heavy Queries

    Design a data structure that preprocesses an array in linear time to answer duplicate-within-distance-k queries in constant time.

    Software Engineering FundamentalsTechnical ScreenHash TableSliding WindowArray
  • GoogleMediumSoftware Engineer
    Explain what happens when you run ls

    This question evaluates a candidate's understanding of process creation and execution, shell command resolution, kernel and VFS filesystem interactions, and how directory entries and file metadata are retrieved; category/domain: Software Engineering Fundamentals.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Explore the Island at a Given Cell With BFS, Then Count Lakes Enclosed by Land

    Given a satellite image as a grid of land and water cells and a starting cell, traverse the island containing that cell with breadth-first search, then extend the solution to count lakes, bodies of water completely enclosed by land. It tests grid traversal, precise problem definitions, connectivity rules and linear-time flood fill.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Find the Most Frequent IP Addresses in a File Too Large for Memory

    Find the ten most frequent normalized IP addresses with cutoff ties preserved, first in memory and then exactly through disk partitioning, per-partition aggregation, global thresholding, and skew handling.

    Software Engineering FundamentalsTechnical Screen
  • GoogleHardSoftware Engineer
    Implement a Lazy Tee Iterator in Python

    This problem tests your understanding of iterator protocols, generator patterns, and memory-efficient data buffering for multi-consumer streams.

    Software Engineering FundamentalsTechnical ScreenPythonIteratorsGenerators
  • GoogleMediumSoftware Engineer
    Implement an HTTP Router That Resolves Handlers for Paths with Named Parameters

    Implement an HTTP router that registers handlers for path patterns, some with named parameters and some without, and looks up the handler and parameter values for a request path. It tests data structure choice, precedence between fixed and parameterized segments, conflict handling and lookup complexity.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Implement quicksort and a binary search tree, and explain how each works internally

    Implement quicksort and a binary search tree from scratch and explain how each works internally, including partitioning, pivot choice, insertion, search and deletion. Tests correctness invariants, best, average and worst-case complexity, duplicate and sorted inputs, alternative approaches, and how library implementations differ.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Layer Config Trees with Pluggable Per-Path Merge Strategies

    Combine a default configuration tree with an environment overlay where each path can pick a merge strategy such as deep, override, preserve, concat, union, or keyed list matching, and new strategies plug in without touching the traversal. Tests simultaneous tree recursion, registry-based extensibility, ordering rules and type-conflict handling.

    Software Engineering FundamentalsTechnical Screenrecursiontreesextensibility
  • GoogleMediumSoftware Engineer
    Merge Two YAML Configuration Trees with Per-Node Merge Rules

    Merge two configuration trees parsed from YAML files, where each node can follow its own merge rule, such as recursive merging, replacing, keeping, appending lists, or matching list items by a key field. Tests recursive traversal of two trees, an extensible way to apply many rules, and careful handling of ordering, one-sided keys and type conflicts.

    Software Engineering FundamentalsTechnical Screen
  • GoogleHardSoftware Engineer
    Project Deep Dive: Kafka Streaming, Redis Caching, and a Go Edge API Gateway

    A resume deep dive from a software engineering intern screen: explain a Kafka streaming architecture and Redis caching from past backend work, then defend choosing Go for a distributed edge API gateway and explain how its latency was managed. Tests ownership, trade-off reasoning and failure handling.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Track the User with the Most Distinct Contacts: O(1) Query and Top-K for Changing k

    Design a class that records undirected messages between users and returns the user who has talked with the most distinct people, then make that query constant time and add a top-K query whose k changes on every call. It tests deduplication with hash sets, space analysis of per-user sets, and incremental ranking structures.

    Software Engineering FundamentalsTechnical Screen
  • GoogleMediumSoftware Engineer
    Trie-Based URL Router with Path Variables and Catch-All Tails

    Implement a request router that registers path templates with {variable} and {*catch-all} segments and resolves a concrete path to its handler and captured values. Tests trie design, literal-over-variable precedence with backtracking, conflict detection, and lookup complexity.

    Software Engineering FundamentalsTechnical Screentriebacktrackingdesign
  • GrammarlyMediumSoftware Engineer
    Implement a rate limiter and a pub/sub API

    This problem evaluates your ability to implement a thread-safe rate limiter using the token bucket algorithm and design a lightweight, in-memory publisher-subscriber system.

    Software Engineering FundamentalsTechnical ScreenConcurrencySystem DesignAPI Design
  • HarveyMediumFrontend Engineer
    Build a Virtualized React Spreadsheet with Cell Formulas

    Design and implement a virtualized React spreadsheet component supporting editable cells, formula evaluation with string concatenation, cycle detection, and targeted re-rendering.

    Software Engineering FundamentalsTechnical ScreenReactVirtualizationGraph Algorithms
  • HarveyMediumSoftware Engineer
    Find Duplicate Files Safely at Scale

    Design and implement a robust file duplicate finder that handles filesystem cycles, minimizes disk I/O using multi-stage filtering, and avoids loading entire large files into memory.

    Software Engineering FundamentalsTechnical ScreenFile SystemsI/O OptimizationHashing
  • HarveyHardSoftware Engineer
    Highlight Overlapping Phrases in a Sentence

    Tests string search algorithms, interval merging techniques, and clean API design for formatting highlighted spans in text without redundant or malformed tags.

    Software Engineering FundamentalsTechnical ScreenStringsIntervalsAho-Corasick
  • HarveyMediumSoftware Engineer
    Incremental Variable Resolver for a Build Pipeline

    Build an in-memory variable resolver for a CI configuration system in three stages: plain integer variables, expression variables that reference other variables, then cycle detection with recomputation limited to the affected dependents. Checks whether a candidate can grow a design incrementally, respect a correct computation order, and reason about a dependency graph under change.

    Software Engineering FundamentalsTechnical Screengraphsdependency-resolutiondesign
  • HarveyMediumSoftware Engineer
    Mini Spreadsheet with Formulas Evaluated in set_cell and Cycle Rejection

    A three-part coding exercise: build a mini spreadsheet with set_cell and get_cell, add formulas that sum constants and cell references with values computed eagerly in set_cell, and detect and reject circular dependencies. It tests dependency graphs, ordered recomputation and cycle checks.

    Software Engineering FundamentalsTechnical Screen
  • HarveyMediumSoftware Engineer
    Spreadsheet Class With Set/Get, Cell-Reference Formulas and Cycle-Rejecting Writes

    Implement an in-memory spreadsheet class in three steps: set and get integer cell values, support formulas that reference other cells, and reject any write that would create a circular reference while leaving the sheet unchanged. It tests dependency tracking, update propagation and cycle detection.

    Software Engineering FundamentalsTechnical Screen
  • HarveyMediumSoftware Engineer
    Spreadsheet Class with Formula Cells, Recalculation and Cycle Detection

    Build an in-memory spreadsheet class in three stages: integer cells with set_cell and get_cell, formula cells such as =B1+C1+1 with explicit handling of never-set cells and recomputation on every write, then cycle detection and recomputing only dependent cells. Tests incremental design, evaluation order and dependency graphs.

    Software Engineering FundamentalsTechnical Screen
  • HeadwayMediumSoftware Engineer
    Implement Layered Endpoint and Global Rate Limits

    This problem tests your ability to design a thread-safe, memory-efficient rate limiter that manages hierarchical quotas using a rolling window mechanism.

    Software Engineering FundamentalsTechnical ScreenConcurrencyRate-LimitingAlgorithms
  • HeygenMediumSoftware Engineer
    Build a GPU VM Fleet CLI

    This problem tests your ability to design a robust CLI interface and state management logic for an abstraction layer that interacts with multiple heterogeneous cloud GPU providers.

    Software Engineering FundamentalsTechnical ScreenSystem DesignCLICloud Computing