Katkat

practice a little every day, paws crossed ♡

Coding & Algorithms 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 871–900 of 3276 results

  • DRWEasySoftware Engineer
    Fewest Expenses to Defer to Year End So the Running Balance Never Goes Negative

    Given a year's transactions in order, with income as positive values, expenses as negative values and a non-negative total, find the fewest expenses to move to the end of the year so the running balance never drops below zero. It tests reasoning over prefix sums for inputs of up to 100,000 transactions.

    Coding & AlgorithmsTechnical Screen
  • DRWEasyData Engineer
    Implement Nested Transactions in an In-Memory Database

    This problem tests your ability to manage state and scope using stacks and dictionaries to implement transaction isolation in a key-value store.

    Coding & AlgorithmsOnline AssessmentHash MapStackTransactions
  • DRWMediumSoftware Engineer
    Largest Number From a 1-and-2 Digit String With Even Counts of Each Digit

    Given a string of 1s and 2s that represents a positive integer, delete characters so the remaining counts of both digits are even, keeping the original order, and return the largest number that can remain. The problem tests careful case analysis of which digit occurrences to remove and efficient string handling for inputs up to 200,000 characters.

    Coding & AlgorithmsHR Screen
  • DRWEasySoftware Engineer
    Longest Substring in Which Every Present Letter Occurs Equally Often

    Given a string of lowercase letters, find the length of the longest substring in which every letter that appears occurs the same number of times. It tests substring enumeration with incremental frequency tracking and a precise definition of what counts as balanced.

    Coding & AlgorithmsTechnical Screen
  • DRWHardSoftware Engineer
    Maximize a Digit Subsequence with Even Counts of Ones and Twos

    Find the lexicographically/numerically largest subsequence of a string of '1's and '2's containing an even number of both digits in linear time.

    Coding & AlgorithmsHR Screengreedystringssubsequences
  • DRWEasySoftware Engineer
    Minimize the Max-Min Gap of an Array After Changing Up to Three Elements

    Given an integer array, you may change up to three elements to any values; return the smallest possible difference between the largest and smallest values afterward. It tests reasoning about which extreme values are worth changing and careful handling of short arrays.

    Coding & AlgorithmsTechnical Screen
  • DRWMediumData Scientist
    Solve movie ratings, array, release scheduler

    This question tests algorithmic problem-solving across three domains: greedy array optimization, tree-based data structure design, and efficient sequence merging. It evaluates practical coding ability and complexity analysis, commonly used in quantitative and data science interviews to assess how candidates identify inefficiencies and select the right data structure to improve performance.

    Coding & AlgorithmsOnsite
  • DRWMediumSoftware Engineer
    Solve odd-string, digit swap, patient slot assignment

    This multi-part problem evaluates string manipulation and parity/combinatorics for constructing odd-occurrence strings, greedy optimization and minimal-change reasoning for digit-swap distance minimization, and bipartite matching/assignment skills for patient slot allocation.

    Coding & AlgorithmsOnline Assessment
  • DRWMediumSoftware Engineer
    Solve three algorithmic OA problems

    This set evaluates algorithmic problem-solving skills including array manipulation and simulation for knockout tournament dynamics, graph traversal and constructive movement-sequence design on grids, and broader competencies in handling permutations, connectivity, and constraint-driven constructions.

    Coding & AlgorithmsOnline Assessment
  • DRWMediumSoftware Engineer
    Solve three algorithmic OA tasks

    Solve three algorithmic OA tasks evaluates algorithm design, data structures, correctness, complexity, edge cases, and implementation details in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

    Coding & AlgorithmsOnline Assessment
  • DRWMediumData Scientist
    Solve three algorithmic tasks in Python

    This question evaluates proficiency in dynamic programming, range-query data structures (Fenwick/segment tree), sorting and two-pointer techniques, and algorithmic complexity analysis within the Coding & Algorithms domain for Python-based implementation.

    Coding & AlgorithmsOnsite
  • DRWEasyData Engineer
    Validate a Password Against Explicit Security Rules

    This problem tests string manipulation, character set validation, and the ability to apply a sequence of conditional checks efficiently.

    Coding & AlgorithmsOnline AssessmentStringsValidationIteration
  • Dark Alpha CapitalMediumSoftware Engineer
    Minimize Total Assignment Distance

    This question evaluates competency in combinatorial optimization, assignment/matching problems, and reasoning about Manhattan distance cost metrics. Commonly asked to assess algorithmic reasoning about constrained assignments, search and complexity trade-offs, it belongs to the Coding & Algorithms domain and emphasizes practical application of algorithm design and implementation rather than purely conceptual theory.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Build a Constant-Time Snapshot Set Iterator

    Design a mutable ordered integer set that supports constant-time snapshot iterator creation without copying the live dataset, preserving insertion order and handling elements that are removed and re-added.

    Coding & AlgorithmsOnsiteData StructuresDesignLinked List
  • DatabricksMediumSoftware Engineer
    Check if CIDR is fully canceled by rules

    This question evaluates understanding of IPv4 CIDR arithmetic, set operations on IP ranges (overlap detection and subtraction), and ordered rule semantics for allow/deny processing.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Choose fastest transportation mode on city grid

    This problem tests your ability to model a grid-based transportation network as a graph and apply Dijkstra's algorithm to find the optimal path under multiple constraints.

    Coding & AlgorithmsTechnical ScreenGraphsDijkstraShortest Path
  • DatabricksMediumSoftware Engineer
    Compute 5-minute rolling average load

    This problem tests your ability to maintain a rolling window average over a high-throughput stream of events using an efficient data structure that balances memory usage and query time complexity.

    Coding & AlgorithmsTechnical ScreenSliding WindowData StructuresTime Series
  • DatabricksMediumSoftware Engineer
    Compute last-5-minute QPS in memory

    This question evaluates design of in-memory data structures and sliding-window time-series aggregation for real-time metrics, testing understanding of space/time trade-offs, streaming algorithms, and handling monotonic timestamps.

    Coding & AlgorithmsTechnical Screen
  • DatabricksHardSoftware Engineer
    Convert an IP range to minimal CIDRs

    This problem tests your ability to manipulate IP address representations and implement a greedy strategy to decompose an arbitrary range of IPv4 addresses into the minimum number of CIDR blocks.

    Coding & AlgorithmsOnsiteBit ManipulationGreedyNetworking
  • DatabricksMediumMachine Learning Engineer
    Delete a Character From Cover

    This problem tests your ability to manage dynamic string indices by maintaining a set of active intervals and adjusting them efficiently after a character deletion.

    Coding & AlgorithmsOnsiteStringsIntervalsArrays
  • DatabricksMediumSoftware Engineer
    Design BFS to detect forced win in Tic-Tac-Toe

    This question evaluates algorithm design and search-space reasoning, focusing on BFS-based game-tree exploration, state representation, symmetry reduction and hashing, win/draw detection, pruning and move-ordering heuristics, and time/space complexity analysis in terms of n, k, t, and the branching factor within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Design IP/CIDR rule matcher

    This question evaluates understanding of IPv4 addressing, CIDR and numeric range representations, plus competency in designing efficient data structures and algorithms for low-latency rule matching with dynamic updates.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumMachine Learning Engineer
    Design In-Memory QPS Counter

    This question evaluates the ability to design and implement an in-memory time-series counter and sliding-window aggregation, emphasizing efficient data structures, handling high-frequency events, and memory-time trade-offs.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Design Tic-Tac-Toe and QPS data structures

    This question evaluates data-structure and API design skills, covering state management and efficient update/query algorithms for a generalized Tic-Tac-Toe with uniform-random move selection, as well as time-series aggregation and streaming-log techniques for computing QPS from non-decreasing timestamps.

    Coding & AlgorithmsOnsite
  • DatabricksMediumSoftware Engineer
    Design a rolling event tracker with ranges

    This question evaluates understanding of time-series data structures and streaming counters, testing algorithm design, space/time complexity analysis, correctness across edge cases, and handling of large-scale event tracking.

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Design an IP filter using CIDR rules

    This question evaluates understanding of IP addressing and CIDR notation, bit-level conversion between prefixes and integer ranges, and the design of scalable data structures and algorithms for prefix/range queries, rule priority handling, and rule-set operations (allow/deny semantics).

    Coding & AlgorithmsTechnical Screen
  • DatabricksMediumSoftware Engineer
    Design an efficient Tic-Tac-Toe engine

    This question evaluates a candidate's understanding of efficient algorithm design and minimal state management for a Tic-Tac-Toe engine on an n x n board, including constraints such as O(1) time per move and O(n) space.

    Coding & AlgorithmsOnsite
  • DatabricksMediumSoftware Engineer
    Design an n x n Tic-Tac-Toe Game

    This problem tests your ability to design an efficient class to manage game state, focusing on constant-time win condition checking using auxiliary data structures.

    Coding & AlgorithmsOnsiteObject-Oriented DesignData StructuresOptimization
  • DatabricksMediumSoftware Engineer
    Detect a K-in-a-Row Win on a Rectangular Board

    Implement an efficient win-detection function that checks whether a newly placed token forms at least k consecutive matching tokens along any linear axis on a rectangular grid.

    Coding & AlgorithmsOnsiteArraysMatrixGame Theory
  • DatabricksHardSoftware Engineer
    Determine allow/deny for an IP via CIDR rules

    This problem tests your ability to efficiently manage and query hierarchical IP address ranges, requiring knowledge of bitwise operations and data structures for range matching.

    Coding & AlgorithmsTechnical ScreenBit ManipulationTrieNetworking