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 1831–1860 of 2629 results

  • Otter.AiMediumSoftware Engineer
    Evaluate Arithmetic Expressions

    This problem tests your ability to parse and evaluate a string representing a mathematical expression with basic operator precedence, typically requiring a stack-based approach or a recursive descent parser.

    Coding & AlgorithmsTechnical ScreenStackString ParsingMath
  • Otter.AiMediumSoftware Engineer
    Fewest Adjacent-GCD Operations to Turn Every Array Element into 1

    Given an array of positive integers, find the fewest operations that make every element 1, where each operation replaces one of two neighboring values with their greatest common divisor, or return -1 if it cannot be done. Tests GCD properties, lower-bound reasoning and careful case analysis on small arrays.

    Coding & AlgorithmsOnsite
  • Otter.AiMediumSoftware Engineer
    Fixed-Width Text Display

    This question tests a candidate's ability to implement greedy line-packing and space-distribution algorithms, core string manipulation skills evaluated in software engineering interviews. It assesses practical application of text layout logic, including handling edge cases like single-word lines and justified formatting with uneven space distribution.

    Coding & AlgorithmsTechnical Screen
  • Otter.AiMediumSoftware Engineer
    Implement an Arithmetic Expression Evaluator

    This problem tests your ability to parse and evaluate mathematical expressions containing non-negative integers, addition, subtraction, multiplication, and nested parentheses using a stack-based approach or recursion.

    Coding & AlgorithmsTechnical ScreenStackParsingMath
  • Otter.AiMediumSoftware Engineer
    In-Memory Key-Value Store with Nested Transactions

    This problem tests the ability to implement a nested transactional key-value store using stack-based state management and scope shadowing.

    Coding & AlgorithmsTechnical ScreenHash MapStackTransactions
  • Otter.AiEasySoftware Engineer
    Validate Password Against Multiple Rules

    This problem tests your ability to efficiently iterate through a string while maintaining multiple state-based flags to satisfy diverse validation criteria.

    Coding & AlgorithmsTechnical ScreenStringsValidationAlgorithms
  • OuraMediumSoftware Engineer
    Implement Server Number Allocation

    This problem tests your ability to manage and reuse resources efficiently using data structures that allow for logarithmic time allocation and deallocation within partitioned namespaces.

    Coding & AlgorithmsOnline AssessmentData StructuresHeapHash Map
  • PalantirMediumSoftware Engineer
    Apply Item Coupons with Exact Per-Item Cent Rounding

    Implement a checkout calculation engine that applies item-specific coupons to cart lines using exact banker's rounding (round-half-to-even) per unit and returns the final cart total in integer cents.

    Coding & AlgorithmsOnline AssessmentSimulationData StructuresMath
  • PalantirEasySoftware Engineer
    Find Shortest Paths in Road Network

    This question evaluates understanding of graph data structures and shortest-path concepts, including correct modeling of undirected edges, unweighted versus weighted pathfinding, and algorithmic time and space complexity.

    Coding & AlgorithmsOnsite
  • PalantirMediumSoftware Engineer
    Group employees by shared interests

    This question evaluates a candidate's competency in organizing and querying collections, mapping relationships between entities, and reasoning about algorithmic time and space complexity within data structures and grouping operations.

    Coding & AlgorithmsTechnical Screen
  • PalantirEasySoftware Engineer
    Merge K Individually Sorted Integer Arrays Into One Sorted Array

    Merge k integer arrays, each sorted in non-decreasing order, into one sorted array that keeps every duplicate. The interviewer asked for the two-pointer method and divide and conquer, so the problem tests merging sorted sequences and how the cost grows with the number of arrays.

    Coding & AlgorithmsTechnical Screen
  • PalantirMediumSoftware Engineer
    Simulate a Growing Snake on a Grid and Report the Score After Every Move

    Simulate a snake moving on a rectangular grid, eating food that appears one piece at a time, and return the score after every move or -1 once the snake leaves the board or runs into itself. It tests precise state simulation, collision rules around the moving tail, and efficient tracking of the snake's body.

    Coding & AlgorithmsTechnical Screen
  • PalantirMediumSoftware Engineer
    Stack Item and Category Coupons with an Eighty-Percent Cap

    Implement a cart checkout calculator that stacks item and category discounts multiplicatively, caps savings at 80%, and applies round-half-up once per item.

    Coding & AlgorithmsOnline AssessmentImplementationMathSimulation
  • Palo Alto NetworksMediumSoftware Engineer
    Find Maximum Rectangle in Bar Chart

    This question evaluates algorithmic problem-solving and data structure proficiency in computing the maximum rectangular area within a histogram-like array, focusing on contiguous segment analysis and range-based aggregation.

    Coding & AlgorithmsOnsite
  • Palo Alto NetworksMediumSoftware Engineer
    Find minimum tanks to cover all houses

    This question evaluates a candidate's proficiency in algorithm design, specifically greedy strategies and string/array manipulation for coverage and optimization under local adjacency constraints.

    Coding & AlgorithmsTechnical Screen
  • Palo Alto NetworksMediumSoftware Engineer
    Find normalized list difference efficiently

    This question evaluates competency in computing normalized list differences, including string normalization, collection comparison, duplicate handling, and time and space complexity reasoning.

    Coding & AlgorithmsOnsite
  • Palo Alto NetworksMediumSoftware Engineer
    Mirror a binary tree and analyze complexity

    This question evaluates understanding of binary tree manipulation and traversal methods, emphasizing recursion and iterative approaches as well as the ability to reason about time and space complexity.

    Coding & AlgorithmsOnsite
  • ParadromicsMediumSoftware Engineer
    Compute ways to climb n steps

    This Coding & Algorithms question evaluates recursion and dynamic programming concepts by asking for the count of distinct ways to climb n steps, framed at an algorithmic/implementation level. It is commonly asked because it probes recognition of overlapping subproblems and the ability to optimize naive recursive approaches through subproblem reuse and improved time/space efficiency.

    Coding & AlgorithmsTechnical Screen
  • ParadromicsMediumSoftware Engineer
    Implement a hash table with put/get

    This question evaluates implementation and design skills for hash-based data structures, testing competency in data structures, hashing, collision handling, and achieving expected O(1) put/get performance in the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • PatreonMediumSoftware Engineer
    Analyze Reports in a Nested Org Chart

    This problem tests your ability to model hierarchical tree structures and use post-order traversal to aggregate data across deep organizational levels efficiently.

    Coding & AlgorithmsTechnical ScreenTreesGraphsRecursion
  • PatreonEasySoftware Engineer
    Design org chart lookup with preprocessing

    This question evaluates skills in data structures and algorithms, specifically tree/forest representation, aggregation of subtree metrics, dynamic updates, and rigorous time and space complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Assess HashMap vs ConcurrentHashMap

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Assess HashMap vs ConcurrentHashMap states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Compare final, finally, finalize

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Compare final, finally, finalize states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Compare write-back vs write-through caches

    This question evaluates understanding of caching policies and memory/storage hierarchy trade-offs, focusing on how write-back and write-through handle writes, coherence, durability, latency, bandwidth, dirty bits, write amplification, and power-loss risks.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Contrast TCP vs UDP; detect loss

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Contrast TCP vs UDP; detect loss states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Explain HashMap internals and collisions

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Explain HashMap internals and collisions states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Explain Java volatile semantics

    This interview question evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer for Explain Java volatile semantics states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Find k most frequent in linear time

    This question evaluates a candidate's ability to design and analyze efficient frequency-counting algorithms and related data structures, testing competencies in hashing, bucket-based grouping, heap usage, and time/space complexity reasoning.

    Coding & AlgorithmsTechnical Screen
  • PayPalMediumSoftware Engineer
    Minimize a String Using Allowed Swaps

    This question evaluates understanding of graph connectivity and constrained string reordering, along with proficiency in applying efficient data structures and algorithms for handling large inputs.

    Coding & AlgorithmsOnsite
  • PayPalMediumSoftware Engineer
    Solve common search/parse/graph frequency tasks

    This problem tests your ability to perform a binary search on a rotated sorted array and subsequently count occurrences of elements to identify the top-k most frequent items.

    Coding & AlgorithmsTechnical ScreenBinary SearchHash TableHeap