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 4021–4050 of 5874 results

  • OpenAIHardSoftware Engineer
    Implement IP Address Arithmetic

    Implement parsing, binary representation, arithmetic offsets, and canonical formatting for both IPv4 and IPv6 addresses and CIDR subnets.

    Coding & AlgorithmsOnsitebit-manipulationstring-parsingnetworking
  • 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 Three Research Coding Tasks

    This problem tests fundamental understanding of numerical stability in probability, memory-efficient buffering, and greedy combinatorial optimization.

    Coding & AlgorithmsHR ScreenNumerical StabilityDynamic ProgrammingStreaming Algorithms
  • 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 ledger with expiring grants and out-of-order operations

    Implement a GPU credit ledger with grant, subtract and get-balance operations, where grants expire and spending draws from the soonest-expiring grant first. Operations can arrive out of timestamp order, and a follow-up asks how to avoid replaying the whole history from time zero on every query in production.

    Software Engineering FundamentalsOnsite
  • 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
  • OpenAIHardSoftware Engineer
    Implement a Set with Readable Snapshots

    Design and implement a versioned set data structure that supports membership modifications, instant snapshotting, and historical point-in-time queries efficiently.

    Software Engineering FundamentalsOnsiteData StructuresDesignBinary Search
  • OpenAIMediumSoftware Engineer
    Implement a Simple Memory Allocator

    This question evaluates low-level memory management and allocator design skills, including block header layout, free-list/data-structure choices, pointer arithmetic, fragmentation concepts, and analysis of time/space complexity.

    Software Engineering FundamentalsOnsite
  • 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 Iterator

    This problem tests your ability to handle IPv4 address arithmetic, bitwise operations, and the implementation of a stateful iterator that supports bidirectional traversal and range generation from CIDR notation.

    Coding & AlgorithmsOnsiteBit ManipulationIterator PatternNetworking
  • 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
  • OpenAIHardSoftware Engineer
    Implement an in-memory SQL-like table

    This question evaluates implementation skills for an in-memory SQL-like table, focusing on data modeling with nested key-value structures, string handling, efficient lookups, and lexicographic sorting with tie-breaking.

    Coding & AlgorithmsOnsite
  • 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