Circular buffer for streaming data in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Circular Buffer Write and Read

Consider a circular buffer of size 4 initialized with zeros. We write the values [1, 2, 3, 4, 5] sequentially. What will be the buffer content after all writes?

Signal Processing

buffer = [0, 0, 0, 0]
size = 4
write_pos = 0
values = [1, 2, 3, 4, 5]

for v in values:
    buffer[write_pos] = v
    write_pos = (write_pos + 1) % size

print(buffer)

A [5, 2, 3, 4]

B [1, 2, 3, 4]

C [2, 3, 4, 5]

D [1, 5, 3, 4]

💡 Hint

Remember the buffer overwrites old values when full.

The buffer size is 4. Writing 5 values means the first value (1) is overwritten by the last (5), resulting in [5, 2, 3, 4].

❓ data_output

intermediate

Number of Valid Samples in Circular Buffer

A circular buffer of size 6 starts empty. After writing 4 samples, how many valid samples does it contain?

Signal Processing

size = 6
valid_samples = 0
write_count = 4

valid_samples = min(write_count, size)
print(valid_samples)

A 0

B 10

C 6

D 4

💡 Hint

The buffer cannot have more valid samples than its size.

Since only 4 samples are written and buffer size is 6, valid samples count is 4.

🔧 Debug

advanced

Identify the Error in Circular Buffer Indexing

What error will this code raise when reading from the circular buffer?

buffer = [10, 20, 30]
size = 3
read_pos = 3
value = buffer[read_pos]
print(value)

Signal Processing

buffer = [10, 20, 30]
size = 3
read_pos = 3
value = buffer[read_pos]
print(value)

A No error, prints 10

B TypeError: unsupported operand type(s)

C IndexError: list index out of range

D ValueError: invalid literal for int()

💡 Hint

Check if the read position is within valid index range.

Index 3 is out of range for a list of size 3 (indices 0 to 2), causing IndexError.

🧠 Conceptual

advanced

Why Use a Circular Buffer for Streaming Data?

Which is the main advantage of using a circular buffer for streaming data?

A It allows continuous data storage without reallocating memory by overwriting old data.

B It sorts the data automatically as new data arrives.

C It encrypts the data for secure transmission.

D It compresses the data to save memory space.

💡 Hint

Think about memory use and continuous data flow.

Circular buffers reuse fixed memory by overwriting oldest data, enabling efficient streaming without growing memory.

🚀 Application

expert

Calculate Average of Last N Samples in Circular Buffer

Given a circular buffer of size 5 with values [4, 7, 2, 9, 5] and a write position at index 2, what is the average of the last 3 samples written?

Signal Processing

buffer = [4, 7, 2, 9, 5]
size = 5
write_pos = 2
n = 3

# Calculate indices of last n samples
indices = [(write_pos - i - 1) % size for i in range(n)]
last_samples = [buffer[i] for i in indices]
avg = sum(last_samples) / n
print(round(avg, 2))

A 5.67

B 5.33

C 6.00

D 4.67

💡 Hint

Remember to wrap indices using modulo and sum the correct samples.

Write position 2 means last written samples are at indices 1, 0, and 4: values 7, 4, and 5. Average is (7+4+5)/3 = 5.33.

Practice

1. What is the main purpose of a circular buffer in streaming data processing?

easy

A. To compress data for storage

B. To sort data in ascending order

C. To permanently save all incoming data without deletion

D. To store a fixed amount of recent data by overwriting old data

Solution

1. Step 1: Understand circular buffer concept

   A circular buffer stores data in a fixed-size space and overwrites old data when full.

2. Step 2: Compare options with concept

   Only To store a fixed amount of recent data by overwriting old data describes overwriting old data to keep recent data, matching the circular buffer purpose.

3. Final Answer:

   To store a fixed amount of recent data by overwriting old data -> Option D

4. Quick Check:

   Circular buffer = overwrite old data [OK]

Hint: Circular buffers overwrite old data to keep recent only [OK]

Common Mistakes:

• Thinking circular buffer sorts data
• Assuming it stores all data permanently
• Confusing with data compression

2. Which of the following Python code snippets correctly initializes a circular buffer of size 5 using a list?

easy

A. buffer = [None] * 5

B. buffer = list(range(5))

C. buffer = []

D. buffer = [0]

Solution

1. Step 1: Identify circular buffer initialization

   A circular buffer needs a fixed-size list to hold data, initialized with placeholders like None.

2. Step 2: Check each option

   buffer = [None] * 5 creates a list of size 5 with None values, suitable for a circular buffer. Others do not create fixed-size buffers.

3. Final Answer:

   buffer = [None] * 5 -> Option A

4. Quick Check:

   Fixed-size list = [None]*5 [OK]

Hint: Use [None]*size for fixed-size buffer list [OK]

Common Mistakes:

• Using empty list which is size zero
• Using range which creates fixed values, not placeholders
• Using single element list instead of fixed size

3. Given this Python code for a circular buffer of size 3, what will be the content of buffer after all writes?

buffer = [None] * 3
write_pos = 0
for val in [10, 20, 30, 40]:
    buffer[write_pos] = val
    write_pos = (write_pos + 1) % 3
print(buffer)

medium

A. [40, 20, 30]

B. [30, 40, 10]

C. [40, 10, 20]

D. [10, 20, 30]

Solution

1. Step 1: Trace buffer writes and positions

   Writes happen at positions 0,1,2, then wrap to 0 again. Values written: 10->pos0, 20->pos1, 30->pos2, 40->pos0 (overwrite 10).

2. Step 2: Determine final buffer content

   After all writes, buffer = [40, 20, 30] because 40 overwrites 10 at position 0.

3. Final Answer:

   [40, 20, 30] -> Option A

4. Quick Check:

   Last write overwrites pos0 = 40 [OK]

Hint: Last write overwrites oldest position using modulo [OK]

Common Mistakes:

• Ignoring wrap-around and overwriting
• Assuming buffer grows beyond fixed size
• Miscalculating write_pos modulo

4. Identify the error in this circular buffer update code snippet:

buffer = [None] * 4
write_pos = 0
for val in [5, 6, 7, 8, 9]:
    buffer[write_pos] = val
    write_pos = write_pos + 1  # Missing modulo operation
print(buffer)

medium

A. buffer initialization with None is incorrect

B. buffer size should be 5 instead of 4

C. write_pos should reset to 0 after reaching buffer size

D. Loop should run only 4 times

Solution

1. Step 1: Analyze write_pos update logic

   write_pos increments but never resets or wraps, so it will go out of buffer index range.

2. Step 2: Identify fix for circular behavior

   write_pos must use modulo with buffer size to wrap around and overwrite old data correctly.

3. Final Answer:

   write_pos should reset to 0 after reaching buffer size -> Option C

4. Quick Check:

   Modulo needed for circular index [OK]

Hint: Use modulo to wrap write_pos in circular buffer [OK]

Common Mistakes:

• Forgetting modulo causes index error
• Changing buffer size instead of fixing index
• Thinking initialization is wrong

5. You have a circular buffer of size 4 storing sensor readings. After 6 readings, the buffer contains [15, 18, 20, 22]. Which readings were overwritten and what is the order of readings from oldest to newest?

hard

A. The first two readings overwritten; order is [15, 18, 20, 22]

B. Readings 15 and 18 overwritten; order is [20, 22, 15, 18]

C. The first two readings overwritten; order is [20, 22, 15, 18]

D. Readings 20 and 22 overwritten; order is [15, 18, 20, 22]

Solution

1. Step 1: Understand buffer size and writes

   Buffer size is 4, but 6 readings were written, so first 2 readings were overwritten by the last 2.

2. Step 2: Determine overwritten readings and order

   First two readings (positions 0 and 1) were overwritten. The buffer shows latest 4 readings: 15,18,20,22. The oldest is at write_pos (2), so order from oldest to newest is [20, 22, 15, 18].

3. Final Answer:

   Readings 15 and 18 overwritten; order is [20, 22, 15, 18] -> Option B

4. Quick Check:

   Overwrite first 2; order starts at write_pos [OK]

Hint: Oldest data starts at write_pos after wrap [OK]

Common Mistakes:

• Confusing which readings are overwritten
• Not understanding order after wrap
• Assuming buffer grows beyond fixed size