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 421–450 of 625 results

  • PilotEasySoftware Engineer
    Explain Python and Web Basics

    This question evaluates foundational competencies in Python language semantics (list vs tuple, identity vs equality) and web fundamentals (HTTP vs HTTPS, CRUD and API concepts), assessing knowledge of data structures, object identity, protocol security, and how CRUD operations map to web services.

    Software Engineering FundamentalsTechnical Screen
  • PinduoduoMediumSoftware Engineer
    Trace Java Static and Instance Field Initialization

    This question tests the understanding of Java class loading, static initialization blocks, and the order of operations between class-level and instance-level fields.

    Software Engineering FundamentalsTechnical ScreenJavaJVMStatic-Initialization
  • PinterestMediumSoftware Engineer
    Design Blackjack Hands, Splits, and a Multi-Deck Shoe

    This problem tests object-oriented design principles, specifically the ability to model a card game with multiple decks, complex state transitions (like splitting), and encapsulation of game rules.

    Software Engineering FundamentalsTechnical ScreenObject-Oriented DesignSystem ModelingGame Logic
  • PinterestEasySite Reliability Engineer
    Fetch a Field from Two URLs, Extract Valid IP Addresses, and Rank Them by Count

    A practical scripting exercise for a site reliability role: send GET requests with a required header to two URLs, pull a text field from each response, extract every valid IP address, and rank the addresses by how often they appear. It tests HTTP error handling, strict IPv4 validation, code reuse and deterministic sorting.

    Software Engineering FundamentalsTechnical Screen
  • PinterestMediumSoftware Engineer
    Generate Attribute Combinations

    Explain Cartesian-product generation for attribute choices while preserving mixed value types and making ordering, duplicates, and empty cases explicit.

    Software Engineering FundamentalsTechnical Screen
  • PinterestMediumSoftware Engineer
    Implement Hierarchical Region Access Overrides

    Design and implement a regional access control system that handles time-based access overrides on a static tree hierarchy with out-of-order updates.

    Software Engineering FundamentalsTechnical ScreenTreeBinary SearchData Structures
  • PinterestMediumSoftware Engineer
    Reconstruct an Itinerary While Keeping an Unspecified Variant Explicit

    Tests finding an Eulerian path in a directed multigraph with lexicographical tie-breaking using Hierholzer's algorithm.

    Software Engineering FundamentalsTechnical Screengraphdfseulerian-path
  • PinterestMediumData Engineer
    Settle Shared-Expense Debts, Then Reduce the Number of Payments

    A coding question about settling shared expenses: turn a list of debts between people into payments that leave everyone even, first with no limit on the number of payments and then with as few payments as possible. It tests net-balance reasoning, matching payers with receivers, heap usage, and judging whether a greedy settlement is truly minimal.

    Software Engineering FundamentalsTechnical Screen
  • PinterestMediumData Engineer
    Settle a Group Tab With the Fewest Possible Payments

    Turn a list of recorded debts between friends into a list of payments that settles every balance, first with any valid list and then with the fewest payments possible, using net-balance accounting and a backtracking search over who pays whom.

    Software Engineering FundamentalsTechnical Screengraphsbacktrackinggreedy
  • PlaystationEasySoftware Engineer
    Groom a Ticket to Replace a Store's 12+ Age Rating with a Pending Rating

    A ten-minute ticket-grooming exercise in which a software engineer and a product manager groom a ticket that removes a game store's 12+ age rating and adds a Pending rating. It tests asking scope-changing questions, splitting the work into parallel tasks with clear dependencies, and giving a reasoned ETA.

    Software Engineering FundamentalsTechnical Screen
  • PlaystationMediumSoftware Engineer
    Refactor a Shopping Cart to Print Grouped, Promoted, Sorted Receipts

    A 30-minute object-oriented exercise that turns a stream of item names into a printed receipt, then extends it to group items by type, apply a buy-three-get-two-free promotion and sort the lines alphabetically. It tests refactoring a shopping cart's storage and its add and remove methods, exact money handling and clean class design.

    Software Engineering FundamentalsTechnical Screen
  • Point72HardData Engineer
    Explain Spark Execution and Optimization

    This question evaluates a candidate's understanding of the Apache Spark execution model, lazy evaluation, distributed processing (including jobs, stages, tasks, and shuffles), and performance-tuning considerations for batch and streaming pipelines on columnar data lakes.

    Software Engineering FundamentalsTechnical Screen
  • ProfoundEasySoftware Engineer
    Implement a Credit API Workflow

    This question evaluates a candidate's ability to integrate with RESTful APIs, manage authentication and HTTP responses, automate a client workflow, and organize reusable program logic.

    Software Engineering FundamentalsTechnical Screen
  • PurestorageMediumSoftware Engineer
    Fix Thread-Safe Trigger Synchronization

    Tests understanding of concurrency primitives, condition variables, thread synchronization, and memory visibility by designing a thread-safe one-shot trigger coordinating multiple waiting threads.

    Software Engineering FundamentalsTechnical Screenconcurrencymultithreadingsynchronization
  • Pylon LendingMediumSoftware Engineer
    Build a Chainable Python SQL Query Builder with Where, Alias and Join Support

    Implement a small Python query builder with a fluent API covering table, select, where with condition objects, alias and a join on a shared column, where render() must return the exact SQL string an existing test suite expects. It tests clause ordering, literal quoting, alias qualification and builder design.

    Software Engineering FundamentalsTechnical Screen
  • QualcommMediumSoftware Engineer
    Explain C++ and GPU Tradeoffs

    This question evaluates understanding of C++ language semantics (enum varieties, default values, aggregate initialization, implicit conversions, struct memory layout and padding), differences between preprocessing and compiled functions (macros versus inline/type-safe functions), and GPU performance trade-offs such as memory access patterns, coalescing, vectorized loads, and shared-memory staging. It is commonly asked to probe low-level reasoning about compilation versus preprocessing, type- and runtime-level trade-offs, and performance and power-efficiency in parallel kernels; it falls under Software Engineering Fundamentals and tests both conceptual understanding and practical application.

    Software Engineering FundamentalsTechnical Screen
  • Qube Research & TechnologiesHardSoftware Engineer
    Differentiate smart pointers and raw pointers

    This question tests the candidate's deep understanding of C++ memory management, RAII principles, and the specific use cases for raw versus smart pointers.

    Software Engineering FundamentalsTechnical ScreenC++Memory ManagementRAII
  • Qube Research & TechnologiesHardSoftware Engineer
    Explain left-skewed returns and Black–Scholes terms

    This question tests the ability to interpret statistical properties of return distributions and explain the financial intuition behind the Black–Scholes option pricing model.

    Software Engineering FundamentalsTechnical ScreenQuantitative FinanceStatisticsDerivatives
  • RampMediumSoftware Engineer
    Crawl an HTTP-served maze to its exit with 503 retries, dead ends and cycles

    Write a client that explores a maze served over HTTP, where each step returns JSON listing next step IDs, until it reaches the response carrying an exit message. Tests graph traversal with cycles and dead ends, bounded retries with backoff for a flaky server returning 503, and keeping network handling separate from search logic.

    Software Engineering FundamentalsTechnical Screen
  • RampHardSoftware Engineer
    Design Calendar Event CRUD with Unit Tests

    Design and implement a robust in-memory calendar event service supporting full CRUD operations, conflict detection, and search, along with a comprehensive suite of unit test cases.

    Software Engineering FundamentalsTechnical ScreenAPI DesignUnit TestingIntervals
  • RampMediumSoftware Engineer
    Design a Bank Account OOP Simulation with Transfers, Payments, and Merges

    This problem tests your ability to design a robust object-oriented system that enforces financial invariants (no negative balances, atomic transfers) and handles complex object lifecycle management like merging accounts.

    Software Engineering FundamentalsTechnical ScreenOOPConcurrencyDesign Patterns
  • RampMediumSoftware Engineer
    Find a User's Airport at a Given Time from Flight Records

    This problem tests your ability to manage and query interval-based time-series data, specifically determining state (location) by processing ordered flight events.

    Software Engineering FundamentalsTechnical ScreenSortingBinary SearchIntervals
  • RampMediumSoftware Engineer
    Find the Exit of an HTTP URL Maze Despite Flaky 503s and Bad JSON

    A coding exercise to find the exit of a maze of HTTP endpoints, where each JSON response lists the next paths to visit until one returns a congrats message. It tests graph traversal with deduplication, URL handling, and robust treatment of flaky 503 responses and malformed JSON with bounded retries.

    Software Engineering FundamentalsTechnical Screen
  • RampMediumSoftware Engineer
    Implement Spreadsheet Cells with Dependencies

    This problem tests graph theory fundamentals, specifically cycle detection and topological sorting in the context of a dependency-driven computation engine.

    Software Engineering FundamentalsTechnical ScreenGraphDFSTopological Sort
  • RampMediumSoftware Engineer
    Implement a Per-IP Sliding Window Rate Limiter

    Implement a per-IP sliding window rate limiter that tracks request timestamps to enforce rate limits over a rolling time window. The problem evaluates state management, time-window data structures, memory leak prevention, and edge-case handling.

    Software Engineering FundamentalsTechnical Screenrate-limitingsliding-windowdata-structures
  • RampMediumSoftware Engineer
    Implement a Single-Screen Tic-Tac-Toe Game with State Management

    This problem tests your ability to model state transitions, encapsulate game logic, and handle user interactions in a clean, maintainable way.

    Software Engineering FundamentalsTechnical ScreenState ManagementLogicObject-Oriented Programming
  • RampMediumSoftware Engineer
    Navigate a Maze Through a Next-Step API

    Design an algorithm to find an exit path in an unknown maze using an interactive, stateful API with backtracking.

    Software Engineering FundamentalsTechnical ScreenDFSBacktrackingGraph Traversal
  • RampHardSoftware Engineer
    Reconcile Records Across Sources

    This question evaluates entity resolution, record linkage, data normalization, conflict resolution, and data quality competencies within the Software Engineering Fundamentals domain by probing how to identify, group, and produce canonical person records from multiple noisy sources.

    Software Engineering FundamentalsTechnical Screen
  • RedditHardSoftware Engineer
    Design Add, Overwrite, Undo, and Redo for Billing State

    Design an in-memory billing account state manager that supports delta adjustments, absolute balance overwrites, and robust undo/redo capabilities.

    Software Engineering FundamentalsTechnical ScreenObject-Oriented DesignStackState Machine
  • RedditMediumBackend Engineer
    Design Tennis Scoring with Pluggable Rules

    Design a testable tennis game scoring component with point recording, readable scores, terminal-state handling, and stable player identity. Keep standard Deuce and Advantage rules separate from pluggable alternatives such as no-ad scoring, and discuss audit history and serialization.

    Software Engineering FundamentalsTechnical Screen