Book Allocation Problem

import java.util.*;

class Solution {
    /*Function to count the number of 
    students required given the maximum 
    pages each student can read*/
    private int countStudents(int[] nums, int pages) {
        // Size of array
        int n = nums.length;
        
        int students = 1;
        int pagesStudent = 0;
        
        for (int i = 0; i < n; i++) {
            if (pagesStudent + nums[i] <= pages) {
                // Add pages to current student
                pagesStudent += nums[i];
            } else {
                // Add pages to next student
                students++;
                pagesStudent = nums[i];
            }
        }
        return students;
    }
    
    /* Function to allocate the book to ‘m’ 
    students such that the maximum number 
    of pages assigned to a student is minimum*/
    public int findPages(int[] nums, int m) {
        int n = nums.length;
        
        // Book allocation impossible
        if (m > n) return -1;

        // Calculate the range for search
        int low = Integer.MIN_VALUE;
        int high = 0;
        for(int i = 0; i < n; i++){
            low = Math.max(low, nums[i]);
            high = high + nums[i];
        }

        // Binary search for minimum maximum pages
        while (low <= high) {
            int mid = (low + high) / 2;
            int students = countStudents(nums, mid);
            if (students > m) {
                low = mid + 1;
            }
            else {
                high = mid - 1;
            }
        }
        return low;
    }

    public static void main(String[] args) {
        int[] arr = {25, 46, 28, 49, 24};
        int m = 4;

        // Create an instance of the Solution class
        Solution sol = new Solution();

        int ans = sol.findPages(arr, m);

        // Output the result
        System.out.println("The answer is: " + ans);
    }
}

class Solution:
    """Function to count the number of 
    students required given the maximum 
    pages each student can read"""
    def countStudents(self, nums, pages):
        # Size of array
        n = len(nums)
        
        students = 1
        pagesStudent = 0
        
        for i in range(n):
            if pagesStudent + nums[i] <= pages:
                # Add pages to current student
                pagesStudent += nums[i]
            else:
                # Add pages to next student
                students += 1
                pagesStudent = nums[i]
        
        return students
    
    """Function to allocate the book to ‘m’ 
    students such that the maximum number 
    of pages assigned to a student is minimum"""
    def findPages(self, nums, m):
        n = len(nums)
        
        # Book allocation impossible
        if m > n:
            return -1
        
        # Calculate the range for binary search
        low = max(nums)
        high = sum(nums)
        
        # Binary search for minimum maximum pages
        while low <= high:
            mid = (low + high) // 2
            students = self.countStudents(nums, mid)
            if students > m:
                low = mid + 1
            else:
                high = mid - 1
                
        return low

if __name__ == "__main__":
    arr = [25, 46, 28, 49, 24]
    m = 4

    # Create an instance of the Solution class
    sol = Solution()

    ans = sol.findPages(arr, m)

    # Output the result
    print("The answer is:", ans)

class Solution {
    /* Function to count the number of 
    students required given the maximum 
    pages each student can read */
    countStudents(nums, pages) {
        // Size of array
        let n = nums.length;
        
        let students = 1;
        let pagesStudent = 0;
        
        for (let i = 0; i < n; i++) {
            if (pagesStudent + nums[i] <= pages) {
                // Add pages to current student
                pagesStudent += nums[i];
            } else {
                // Add pages to next student
                students++;
                pagesStudent = nums[i];
            }
        }
        return students;
    }

    /* Function to allocate the book to ‘m’ 
    students such that the maximum number 
    of pages assigned to a student is minimum */
    findPages(nums, m) {
        // Size of array
        let n = nums.length;
        
        // Book allocation impossible
        if (m > n) return -1;

        let low = Math.max(...nums);
        let high = nums.reduce((a, b) => a + b, 0);

        // Binary search for minimum maximum pages
        while (low <= high) {
            var mid = Math.floor((low + high) / 2);
            var students = this.countStudents(nums, mid);
            if (students > m) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return low;
    }
}

function main() {
    let nums = [25, 46, 28, 49, 24];
    let m = 4;

    // Create an instance of the Solution class
    let sol = new Solution();

    let ans = sol.findPages(nums, m);

    // Output the result
    console.log("The answer is:", ans);
}

// Call the main function
main();