Software Engineering Fundamentals interview questions

Showing 91–120 of 1208 results

• Simplify an Arithmetic Expression Tree with Constant Folding and IdentitiesMedium

  Given the abstract syntax tree of an arithmetic expression as a binary tree, write a traversal that returns an equivalent simplified tree using constant folding and algebraic identities. It tests recursive tree processing, cascading rewrites, correct handling of non-commutative operators and recursion-depth limits.

  AmazonSoftware EngineerSoftware Engineering FundamentalsOnsite
• Validate AI-Generated Code SafelyMedium

  Implement a static validation engine that inspects an Abstract Syntax Tree (AST) representation of AI-generated code to enforce security, safety, and complexity boundaries.

  AmazonSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Debug and Extend a Nested-Class ProgramEasy

  This problem tests your ability to identify state synchronization issues in nested class structures and implement a thread-safe extension to existing class logic.

  AmericanSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Structure a Pizza-Ordering System with Four Discount PoliciesMedium

  Design an extensible object-oriented order pricing system for a pizzeria that models pizzas, applies four distinct discount policies with specific composition rules, and returns an itemized, explainable receipt.

  AmericanSoftware EngineerSoftware Engineering FundamentalsOnline Assessment
• Implement the Core of MinesweeperHard

  Design an object-oriented Minesweeper game engine featuring state management, board generation, flood-fill cell revealing, and testable boundaries.

  AmperitySoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Diagnose a Memory Leak in a JavaScript Web ApplicationMedium

  Tests your ability to identify common JavaScript memory leak patterns—such as detached DOM trees, uncleared event subscriptions, and unbounded closures—and verify resolution using browser heap profiling techniques.

  AndurilFrontend EngineerSoftware Engineering FundamentalsOnsite
• Explain Hash Map Collisions and Operation ComplexityMedium

  Tests in-depth understanding of hash table internals, comparing collision resolution mechanisms, deletion strategies, dynamic resizing, and operation complexities under expected and adversarial conditions.

  AndurilSoftware EngineerSoftware Engineering FundamentalsOnsite
• Batch Key Lookups Into One HTTP Request per 100 ms With CallbacksMedium

  A callback-based batching exercise: implement start_fetch(key, callback) so that lookups made within a 100 ms window are sent to a /get?keys= endpoint as one HTTP request, using only http_get_request and set_timeout. It tests timer scheduling, per-key callback bookkeeping and keeping overlapping in-flight batches apart on an event loop.

  AnrokSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Batch Image Resize and Rotate with Pillow: Exact Dimensions, Parallelism, Bad FilesMedium

  A three-part Python image processing exercise: resize and rotate images with Pillow while predicting the exact printed dimensions, speed up a large batch with multiprocessing and a staged pipeline, then keep the batch running through corrupt, oversized and unsupported files. It tests API precision, parallelism and robustness.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Batch-Apply Pillow Image Transforms, Then Parallelize: Processes vs ThreadsHard

  A Python coding exercise that applies a given sequence of Pillow transforms to a folder of cat images and then asks you to cut the total processing time. It tests clean per-image code, reasoning about CPU-bound work and the GIL, choosing between processes and threads, and sizing a worker pool.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Build a Resize-and-Rotate Image Pipeline with MultiprocessingMedium

  Design a Pillow resize-and-rotate pipeline with explicit transform semantics, bounded multiprocessing, per-image failures, and safe output publication.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Compare Threads and Processes for Image ProcessingMedium

  Tests operating system concurrency fundamentals, memory ownership models, IPC serialization overhead, and empirical benchmarking strategies for CPU-bound image processing pipelines.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Compute a Global Mode Across Distributed PartitionsHard

  Compute an exact distributed mode with local frequency combining, key-based reducers, global winner selection, communication accounting, and skew-aware recovery.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Compute an Exact Distributed Median with Limited CommunicationHard

  Compute an exact distributed median through global rank selection and count reductions, accounting for integer range, local search work, communication rounds, and even-size semantics.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Convert Sampled Call Stacks into Timestamped Function Start and End EventsMedium

  Convert a sampling profiler's timestamped call stacks into function start and end events for a trace viewer, explain why ends are emitted innermost first and starts outermost first, then redesign the converter for an unbounded stream. It tests stack diffing, recursion handling and streaming state.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Debug Python LRU Cache-Key ConstructionHard

  Implement and debug a thread-safe, bounded LRU memoization decorator that generates canonical cache keys across equivalent argument patterns, distinguishes conflicting types, and avoids caching exceptions.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Debug Tokenization and DetokenizationHard

  Implement and debug a prefix-based tokenizer and detokenizer class, ensuring deterministic longest-match greedy tokenization, strict vocabulary validation, explicit error handling for unencodable characters, and guaranteed round-trip fidelity.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design Distributed Sorting Around an Explicit Helper ContractMedium

  Design and implement the coordination logic for a distributed range-based sort across multiple worker nodes, specifying the worker helper contract and handling key skew and duplicate values.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Design a Parallel Image ProcessorMedium

  This problem tests your ability to design a thread-safe, parallelized image processing framework that handles neighborhood-based pixel operations without race conditions.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain CPU-Bound vs I/O-Bound WorkHard

  This question evaluates understanding of CPU-bound versus I/O-bound workloads and their interaction with concurrency models such as multithreading, asynchronous I/O, and multiprocessing in Python, including the impact of the Global Interpreter Lock (GIL) and relevance to tasks like web crawling, parsing, and heavy computation.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Explain multithreading vs multiprocessingMedium

  This question tests your conceptual understanding of how process-based and thread-based concurrency models leverage hardware resources and their respective trade-offs in the context of Python and high-performance ML workloads.

  AnthropicMachine Learning EngineerSoftware Engineering FundamentalsOnsite
• Find Duplicate Files by Content in a Directory Tree and Explain CPU vs I/O CostsMedium

  Walk a directory tree and report every group of files with identical contents, printing nothing when there are no duplicates. It tests staged filtering by size and hashes, streaming reads of large files, link and error handling, and reasoning about whether the job is CPU-bound or I/O-bound.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Fix a Buggy LRU Cache, Then Make It Durable with a Write-Ahead LogMedium

  Debug a flawed least-recently-used cache by finding each bug with a reproducing call sequence and fixing it, then make the cache durable across crashes with a write-ahead log and snapshots. It tests careful code reading, constant-time LRU design, crash-consistent persistence and recovery.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Function-Call LRU Cache: Argument Key Generation and Crash Recovery from a LogHard

  A Python exercise that builds an LRU cache for memoizing function calls. Part one asks how to generate a reliable cache key from a function and its arguments; part two adds crash recovery through an append-only log file, testing record framing, durability, torn writes and replay of the cache state.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• How do you review a design document?Hard

  This question assesses a candidate's ability to critically evaluate technical design documentation by identifying architectural risks, scalability bottlenecks, and gaps in operational planning.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Implement a Duplicate-File ReporterEasy

  Implement an efficient file system scanner that identifies duplicate files while minimizing disk I/O and gracefully handling filesystem errors.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsTechnical Screen
• Make a Web Crawler Concurrent with Thread-Safe Visited StateMedium

  Convert a sequential crawler to bounded concurrency using atomic URL reservation, explicit retry state, and completion detection that accounts for active fetches.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Mode, Median and Sort Across 10 Nodes with Send/Receive While Minimizing TrafficMedium

  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.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Parallelize a Directory Walker With Thread-Safe Visited TrackingMedium

  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.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite
• Resolve a Package Dependency Graph with Concurrent FetchesMedium

  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.

  AnthropicSoftware EngineerSoftware Engineering FundamentalsOnsite