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 1861–1890 of 2810 results

  • OpenAIMediumSoftware Engineer
    Implement GPU credit ledger

    This question evaluates a candidate's ability to design efficient stateful systems and algorithmic data structures for tracking per-tenant resource balances, including handling idempotency, negative balance policies, concurrency, and persistence.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement IPv4 and CIDR iterators

    This problem tests your ability to manipulate IP address bit-representations and implement a custom iterator to traverse all addresses within a given CIDR block.

    Coding & AlgorithmsTechnical ScreenBitwiseNetworkingIterator
  • OpenAIMediumSoftware Engineer
    Implement KV store and plan type conversions

    This question evaluates proficiency in designing scalable, time-versioned key-value data structures and in graph-based shortest-path planning for costed type conversions, assessing algorithmic thinking, complexity analysis, and robustness under large-scale constraints in the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement KV store serialization

    This question evaluates skills in binary serialization and deserialization, data encoding and layout, type tagging, endianness, checksumming, versioning for forward/backward compatibility, and algorithmic efficiency and space usage for an in-memory key-value store; it falls under the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement Social Follow Recommendations

    This problem tests your ability to navigate a social graph to implement a recommendation system using set operations and frequency counting.

    Coding & AlgorithmsTechnical ScreenGraphHash MapSorting
  • OpenAIMediumSoftware Engineer
    Implement Social Graph Snapshot Queries

    This problem tests your ability to design a query-optimized representation for a directed graph, specifically focusing on efficient retrieval of multi-hop relationships and neighbor-based ranking.

    Coding & AlgorithmsTechnical ScreenGraphsAdjacency ListData Structures
  • OpenAIMediumSoftware Engineer
    Implement Time-Aware GPU Credit Ledger

    Design an in-memory credit ledger that tracks GPU compute grants with expiration timestamps, consumes credits greedily by earliest expiration, and supports atomic deductions.

    Coding & AlgorithmsTechnical ScreenHeap / Priority QueueDesignGreedy
  • OpenAIHardSoftware Engineer
    Implement a Contiguous Memory Allocator with Primitive Lists

    Simulate best-fit allocation across a contiguous address range using only primitive lists and scalar state. Support splitting, exact-pointer frees, double-free rejection, deterministic tie-breaking, and coalescing adjacent free blocks across up to 10,000 operations.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a Distributed Rate Limiter

    Implement a distributed token bucket rate limiter backed by a key-value store with optimistic concurrency control (CAS), handling clock skew, concurrent updates, and token replenishment.

    Coding & AlgorithmsTechnical ScreenDistributed SystemsConcurrencyAlgorithms
  • OpenAIMediumSoftware Engineer
    Implement a GPU credit manager

    This question evaluates understanding of concurrent resource management, advanced data structures for top-K and per-user queries, enforcement of caps and expirations, and algorithmic complexity guarantees while maintaining atomicity under concurrent operations.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a Recoverable In-Memory Key-Value Store

    This problem tests your understanding of durability, logging, and data persistence in an in-memory system.

    Software Engineering FundamentalsTechnical ScreenSystemsConcurrencyPersistence
  • OpenAIMediumSoftware Engineer
    Implement a fault-tolerant work queue that never loses tasks when workers fail

    Implement an in-process work queue that never loses a task when the worker holding it crashes, stalls or reports an error. It tests task state tracking, detecting silent workers, rejecting late reports from workers that lost a task, bounded retries for tasks that always fail, thread safety, and deterministic tests built on an injected clock.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a memory allocator with malloc/free

    This question evaluates understanding of memory allocator concepts including malloc/free semantics, contiguous allocation, fragmentation handling, coalescing of adjacent free blocks, pointer validation, and data-structure choices for efficient allocation.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement a minimal reverse-mode autograd engine on PyTorch tensors

    Implement the core of a PyTorch-style autograd system: a tensor wrapper that records addition, multiplication, matrix multiplication, ReLU and sum, plus a backward method that fills in gradients for every input. Tests reverse-mode differentiation, correct ordering of the backward pass, gradient accumulation for tensors used more than once, and verification against PyTorch.

    Machine LearningTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement a serializable key-value store

    This question evaluates competency in implementing robust serialization and in-memory data structures, covering binary format design, handling arbitrary bytes and Unicode, correctness across edge cases (empty state, large keys/values, overwrites, deletions), input validation and failure recovery, complexity analysis, and unit testing.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement an Extensible Chatbot App

    This question evaluates a candidate's ability to design extensible object-oriented systems, covering interface-based architecture, dependency injection, per-conversation state management, and decoupled dispatch logic.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement an IPv4 Range Iterator

    This problem tests your ability to manipulate 32-bit integers, understand bitwise operations, and implement a custom iterator for a contiguous range of IP addresses.

    Coding & AlgorithmsTechnical ScreenBit ManipulationNetworkingIterator
  • OpenAIMediumSoftware Engineer
    Implement an expiring GPU credits ledger

    This question evaluates understanding of time-based resource accounting, design of data structures for expiring balances, atomic update semantics for concurrent operations, and algorithmic time/space complexity within the Coding & Algorithms domain.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement and Debug Backprop in NumPy

    This question evaluates understanding of backpropagation and the chain rule, proficiency in vectorized NumPy implementation, numerical stability of softmax/cross-entropy, and competency in gradient checking and debugging of model gradients.

    Machine LearningTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement delimiter-free string codec

    This question evaluates a candidate's ability to design reversible string encodings that handle arbitrary characters and edge cases, testing competency in string manipulation, data serialization, and robustness.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement expiring credit ledger

    This question evaluates the ability to design efficient time-based data structures and algorithms for managing expiring credits with ordering and tie-breaking rules, testing competencies in event ordering, interval management, and retroactive update handling; it is in the Coding & Algorithms domain and emphasizes practical application of algorithmic and data-structure reasoning. It is commonly asked to verify correctness under out-of-order inserts and queries, to assess performance and complexity analysis for add/charge/get operations, and to require clear specification of time and space complexity for the proposed approach.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement follow graph with snapshots

    This problem tests your ability to design a versioned, immutable, or persistent data structure that supports efficient graph modifications and point-in-time snapshot queries.

    Coding & AlgorithmsTechnical ScreenPersistent Data StructuresGraphsVersion Control
  • OpenAIMediumSoftware Engineer
    Implement follow graph with snapshots and recommendations

    This question evaluates design and implementation skills for mutable graph data structures with point-in-time snapshotting and recommendation ranking, testing knowledge of data structures, versioning, graph traversal, and algorithmic time/space complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement in-memory DB querying

    This question evaluates a candidate's competency in data structures, algorithms, and systems-level thinking for implementing query processing in an in-memory database, including projection, predicate filtering, ordering, and index design.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement in-memory KV store with serialization

    This question evaluates skills in designing and implementing an in-memory key-value store with serialization, testing data structure design, API design (set/get/serialize/deserialize), serialization format selection, type fidelity for common Python types, and robust error handling.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement malloc and free over Fixed Memory, Then Make Both Logarithmic

    Implement malloc and free for a fixed range of memory in Python, first with a simple list of blocks and then with logarithmic-time operations backed by a third-party sorted container. It tests block splitting and merging, choosing ordered indexes for allocation and neighbor lookup, and keeping parallel structures consistent.

    Software Engineering FundamentalsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement node messaging and path discovery

    This question evaluates skills in distributed systems and algorithms, including reliable message-passing between adjacent nodes, graph traversal and path discovery, fault-tolerant protocol design, and message/time complexity analysis.

    Coding & AlgorithmsTechnical Screen
  • OpenAIMediumSoftware Engineer
    Implement persistent key-value store

    This question evaluates competency in implementing an in-memory key-value store with persistence, covering concepts such as serialization, durability, data structure management, and basic I/O handling.

    Coding & AlgorithmsTechnical Screen
  • OpenAIHardSoftware Engineer
    Implement type AST and infer generics

    This problem tests your ability to design a recursive data structure for an abstract syntax tree and implement a unification-based type inference engine for a simple functional language.

    Coding & AlgorithmsTechnical ScreenASTType InferenceRecursion
  • OpenAIMediumSoftware Engineer
    Infection Spread Simulation with Death Threshold

    Implement a cellular automaton simulating epidemic spread on a 2D grid with simultaneous infection and mortality transitions until convergence.

    Coding & AlgorithmsTechnical Screenmatrixsimulationbreadth-first-search