Implement a single-producer multi-consumer ring buffer
Company: Citadel
Role: Software Engineer
Category: Coding & Algorithms
Difficulty: medium
Interview Round: Technical Screen
Implement a fixed-capacity ring buffer in **C++** for a setting with **one producer** and **multiple consumers**.
Design a class that stores integers in a preallocated circular array and supports the following operations:
- `RingBuffer(int capacity)`: initialize the buffer with a fixed capacity.
- `bool push(int value)`: insert a value at the tail. Return `false` if the buffer is full.
- `bool pop(int& value)`: remove the oldest value from the head and write it into `value`. Return `false` if the buffer is empty.
- `bool empty() const`
- `bool full() const`
- `int size() const`
Requirements:
- All operations should run in **O(1)** time.
- Use circular indexing to reuse freed space.
- Do not resize the underlying storage.
- Focus on the **object-oriented design** and correct ring-buffer behavior.
- You may assume synchronization is handled externally; the main goal is to implement the ring-buffer logic correctly for a single-producer, multi-consumer use case.
After coding, briefly explain how you would adapt the design if true thread safety were required.
Quick Answer: This question evaluates understanding of ring-buffer data structures, circular indexing, fixed-capacity storage, and object-oriented design for a single-producer, multi-consumer implementation in C++.
Implement the core logic of a fixed-capacity ring buffer, inspired by this C++ interview design: a preallocated circular array that supports one producer and multiple consumers, with synchronization handled externally.
The original API is:
- RingBuffer(int capacity)
- bool push(int value)
- bool pop(int& value)
- bool empty() const
- bool full() const
- int size() const
For automated evaluation, write a function `solution(capacity, operations)` that simulates this class.
Each operation in `operations` is one of:
- `(\"push\", value)` -> insert `value` at the tail, return `True` if successful, `False` if the buffer is full.
- `(\"pop\",)` -> remove the oldest value from the head. Return `(True, value)` if successful, or `(False, None)` if the buffer is empty.
- `(\"empty\",)` -> return whether the buffer is empty.
- `(\"full\",)` -> return whether the buffer is full.
- `(\"size\",)` -> return the current number of elements.
All operations must run in O(1) time. Use circular indexing to reuse freed space, and do not resize the underlying storage.
Follow-up discussion (no code required): briefly explain how you would adapt the design if true thread safety were required in C++.
Constraints
- 1 <= capacity <= 10^5
- 0 <= len(operations) <= 2 * 10^5
- -10^9 <= pushed values <= 10^9