Read N Characters Given Read4 - Solution & Explanation
Problem Statement
Given a file and assume that you can only read the file using a given method read4, implement a method to read n characters.
Method read4:
The API read4 reads four consecutive characters from file, then writes those characters into the buffer array buf4.
The return value is the number of actual characters read.
Note that read4() has its own file pointer, much like FILE *fp in C.
Definition of read4:
Parameter: char[] buf4
Returns: int
buf4[] is a destination, not a source. The results from read4 will be copied to buf4[].
Below is a high-level example of how read4 works:
File file("abcde"); // File is "abcde", initially file pointer (fp) points to 'a'
char[] buf4 = new char[4]; // Create buffer with enough space to store characters
read4(buf4); // read4 returns 4. Now buf4 = "abcd", fp points to 'e'
read4(buf4); // read4 returns 1. Now buf4 = "e", fp points to end of file
read4(buf4); // read4 returns 0. Now buf4 = "", fp points to end of file
Method read:
By using the read4 method, implement the method read that reads n characters from file and store it in the buffer array buf. Consider that you cannot manipulate file directly.
The return value is the number of actual characters read.
Definition of read:
Parameters: char[] buf, int n
Returns: int
buf[] is a destination, not a source. You will need to write the results to buf[].
Note:
- Consider that you cannot manipulate the file directly. The file is only accessible for
read4but not forread. - The
readfunction will only be called once for each test case. - You may assume the destination buffer array,
buf, is guaranteed to have enough space for storingncharacters.
Example 1:
Input: file = "abc", n = 4 Output: 3 Explanation: After calling your read method, buf should contain "abc". We read a total of 3 characters from the file, so return 3. Note that "abc" is the file's content, not buf. buf is the destination buffer that you will have to write the results to.
Example 2:
Input: file = "abcde", n = 5 Output: 5 Explanation: After calling your read method, buf should contain "abcde". We read a total of 5 characters from the file, so return 5.
Example 3:
Input: file = "abcdABCD1234", n = 12 Output: 12 Explanation: After calling your read method, buf should contain "abcdABCD1234". We read a total of 12 characters from the file, so return 12.
Constraints:
1 <= file.length <= 500fileconsist of English letters and digits.1 <= n <= 1000
Approach Overview
Problem Overview: You are given an API read4(char[] buf4) that reads up to 4 characters from a file into buf4. The task is to implement read(char[] buf, int n) that reads exactly n characters (or fewer if the file ends). You cannot access the file directly; the only way to read data is through the read4 API.
Approach 1: Direct read4 Simulation (O(n) time, O(1) space)
The simplest strategy repeatedly calls read4 until you collect n characters or the file ends. Each call fills a temporary buffer of size 4. You then copy characters one by one from this temporary buffer into the destination buf while tracking how many characters have already been written. Stop copying when either n characters are written or the number of characters returned by read4 is less than 4, which signals the end of the file.
This approach is essentially a simulation of chunked file reading. The key detail is controlling two counters: total characters written to the result buffer and characters returned by the current read4 call. The algorithm never reads more than needed because copying stops once n characters are filled. The temporary array has a fixed size of 4, so memory usage remains constant.
Approach 2: Chunk Buffer Copy (O(n) time, O(1) space)
A slightly cleaner implementation treats each read4 call as a chunk. Instead of copying blindly, compute how many characters from the chunk are still required: min(count, n - totalRead). Copy only that portion into the destination buffer. This reduces conditional checks inside the copy loop and makes the logic easier to reason about during interviews.
The algorithm repeatedly reads blocks of four characters into a small buffer, then transfers only the needed part into the final array. Once totalRead reaches n, the process stops immediately even if more characters were available in the chunk. The idea mirrors common array copy patterns where partial segments are moved between buffers.
Recommended for interviews: Interviewers expect the chunk simulation approach. It shows you understand how to work with restricted APIs and manage partial reads. Explaining the control flow around read4, early termination, and copying only the required characters demonstrates solid reasoning about interactive-style problems. Brute forcing without careful counters often leads to off‑by‑one errors, so the chunk‑copy logic is the safest and clearest implementation.
Solution
Try this approach in the editor →Detailed Complexity Analysis
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Direct read4 Simulation | O(n) | O(1) | Baseline solution when implementing read() using repeated read4 calls |
| Chunk Buffer Copy | O(n) | O(1) | Preferred interview implementation with cleaner control of remaining characters |
Video Solution
Leetcode 157/158 Read N Characters Given Read 4 I/II • Ren Zhang • 5,702 views views
Watch 9 more video solutions →Frequently Asked Questions
Is Read N Characters Given Read4 easy or hard?
Read N Characters Given Read4 Python/Java solution
How to solve Read N Characters Given Read4 in O(n)?
What is the best approach for Read N Characters Given Read4?
Is Read N Characters Given Read4 asked at Google/Amazon/Meta?
What data structure is used in Read N Characters Given Read4?
What is the time complexity of Read N Characters Given Read4?
Ready to solve this problem?
Practice Read N Characters Given Read4 with our built-in code editor and test cases.
Practice on FleetCodeTable of Contents
Practice this problem
Open in Editor