Efficient Character Reading with Limited Read4 Calls

This challenge simulates reading data from a file where you can only read 4 characters at a time using a function called read4. Your task is to implement a function that reads N characters from the same file, minimizing the number of read4 calls. This is a common scenario in systems programming and data streaming where access to underlying data is restricted.

Problem Description

You are given a function read4(buffer) that reads up to 4 characters from an underlying file and stores them in the provided buffer. The function returns the actual number of characters read. You need to implement a function readN(buffer, n) that reads exactly N characters from the same file and stores them in the provided buffer.

Key Requirements:

Minimize read4 calls: The goal is to use the fewest possible calls to read4 to achieve the desired result.
Handle incomplete reads: read4 might return fewer than 4 characters if the end of the file is reached or if there are fewer characters available.
Buffer overflow prevention: Ensure that you don't write beyond the bounds of the provided buffer.
Correct character order: The characters in the buffer must be in the same order as they appear in the file.

Expected Behavior:

readN(buffer, n) should read N characters into buffer.
If the file contains fewer than N characters, readN should read all available characters into buffer.
The function should return the number of characters actually read.
The buffer should contain the read characters, terminated by a null character ('\0') if the language requires it.

Edge Cases to Consider:

N = 0: Should return 0 without making any read4 calls.
File is empty: Should return 0 without making any read4 calls.
N is larger than the file size: Should read all characters in the file.
read4 returns 0 (end of file) before N characters are read.

Examples

Example 1:

Input: buffer = [0, 0, 0, 0], n = 5, file contains "abcdefgh"
Output: buffer = ['a', 'b', 'c', 'd', 'e'], return value = 5
Explanation: read4 will be called once, returning "abcd".  A second read4 will be called, returning "efgh". The first 5 characters are copied to the buffer.

Example 2:

Input: buffer = [0, 0, 0, 0], n = 3, file contains "abc"
Output: buffer = ['a', 'b', 'c'], return value = 3
Explanation: read4 will be called once, returning "abc". The first 3 characters are copied to the buffer.

Example 3: (Edge Case)

Input: buffer = [0, 0, 0, 0], n = 7, file contains "abc"
Output: buffer = ['a', 'b', 'c'], return value = 3
Explanation: read4 will be called once, returning "abc". The first 3 characters are copied to the buffer.

Example 4: (Edge Case)

Input: buffer = [0, 0, 0, 0], n = 0, file contains "abcdefgh"
Output: buffer = [0, 0, 0, 0], return value = 0
Explanation: No read4 calls are made.

Constraints

n will be a non-negative integer.
The buffer is an array of characters.
The underlying file is assumed to be finite.
The number of read4 calls should be minimized. While a specific performance target isn't given, strive for an efficient solution.
The read4 function is provided and cannot be modified.

Notes

Consider using a temporary buffer to store the characters read by read4.
Think about how to handle the case where read4 returns fewer than 4 characters.
The read4 function is assumed to return the number of characters read.
The problem focuses on the logic of reading N characters efficiently, not on the implementation of read4 itself.
Pseudocode is acceptable. Focus on the algorithm and its efficiency.

Pseudocode:

function readN(buffer, n):
  read_count = 0
  temp_buffer = [0] * 4  // Temporary buffer to store characters from read4

  while read_count < n:
    chars_read = read4(temp_buffer)

    // Determine how many characters to copy from temp_buffer to buffer
    chars_to_copy = min(chars_read, n - read_count)

    // Copy characters from temp_buffer to buffer
    for i from 0 to chars_to_copy - 1:
      buffer[read_count + i] = temp_buffer[i]

    read_count += chars_to_copy

  return read_count