Read N Characters Given read4 II - Call Multiple Times

Read N Characters Given read4 II - Call Multiple Times - Problem

Imagine you're building a file reader that can only access files through a special API called read4. This API reads exactly 4 characters at a time from a file, but you need to create a flexible read method that can read any number of characters.

Here's the catch: your read method will be called multiple times, and you need to maintain state between calls to continue reading from where you left off.

The read4 API:

Reads up to 4 characters from the file
Returns the actual number of characters read (0-4)
Maintains its own file pointer that advances automatically
Once it reaches the end of file, it always returns 0

Your task: Implement a read(buf, n) method that:

Reads exactly n characters (or until end of file)
Stores the result in the provided buffer buf
Returns the actual number of characters read
Can be called multiple times and maintains proper state

Example: If file contains "abcdefgh" and you call read(buf, 3) then read(buf, 5), the first call should return "abc" and the second should return "defgh".

Input & Output

Basic Multiple Calls

$ Input: File: "abc", Calls: read(buf, 1), read(buf, 2), read(buf, 1)

› Output: Returns: 1, 2, 0, Buffers: ["a"], ["b", "c"], []

💡 Note: First call reads 1 char 'a'. Second call reads remaining 2 chars 'bc'. Third call finds no more characters and returns 0.

Buffer Management Example

$ Input: File: "abcdefg", Calls: read(buf, 3), read(buf, 5)

› Output: Returns: 3, 4, Buffers: ["a", "b", "c"], ["d", "e", "f", "g"]

💡 Note: First call gets 3 chars. Second call gets remaining 4 chars (not 5 because file only has 7 total characters).

Large Request Example

$ Input: File: "ab", Calls: read(buf, 10)

› Output: Returns: 2, Buffer: ["a", "b"]

💡 Note: Request is larger than file size. Method returns only available characters and indicates actual count read.

Constraints

1 ≤ n ≤ 1000
At most 1000 calls will be made to read
0 ≤ file.length ≤ 10⁴
file contains only lowercase English letters
read4 can only be called, cannot be implemented by you

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize internal buffer to store excess characters

Read Request

Check internal buffer first for leftover characters

Call read4

If needed, call read4 to get more characters

Buffer Management

Store unused characters for next call

Key Takeaway

🎯 Key Insight: Use an internal buffer as temporary storage to maintain perfect state between multiple API calls, ensuring no data loss and optimal performance.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses an internal buffer to store leftover characters from read4 calls. This ensures perfect state management across multiple calls while maintaining O(n) time complexity and O(1) space complexity. The key insight is buffering excess characters rather than losing them.

Common Approaches

Approach	Time	Space	Notes
✓ Naive Approach - No State Management	O(n)	O(1)	Call read4 directly each time without managing leftover characters
Optimal - Internal Buffer Management	O(n)	O(1)	Maintain an internal buffer to store leftover characters between calls

Naive Approach - No State Management — Algorithm Steps

Call read4 repeatedly until we have enough characters
Copy characters directly to the output buffer
Return the total characters read

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

read(buf, 3) - reads 4 chars but only uses 3

Second Call

read(buf, 2) - reads next 4 chars, losing the 4th char from first call

Code -

solution.c — C

/* The read4 API is already defined for you.
     int read4(char *buf4); */

int read(char *buf, int n) {
    int total = 0;
    char buf4[4];
    
    while (total < n) {
        int count = read4(buf4);
        if (count == 0) break;
        
        // Copy characters to output buffer
        int copyCount = (count < n - total) ? count : n - total;
        for (int i = 0; i < copyCount; i++) {
            buf[total + i] = buf4[i];
        }
        
        total += copyCount;
    }
    
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We need to read n characters, calling read4 approximately n/4 times

✓ Linear Growth

Space Complexity

O(1)

No additional storage for state management

✓ Linear Space

26.8K Views

High Frequency

~25 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Naive Approach - No State Management — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler