Maximum length of all possible K equal length ropes generated by cutting N ropes

Given an array arr[] consisting of N positive integers representing the lengths of N ropes and a positive integer K, the task is to find the maximum length of the rope that has a frequency of at least K by cutting any ropes in any number of pieces.

Examples:

Input: arr[] = {5, 2, 7, 4, 9}, K = 5
Output: 4
Explanation:
Below are the possible cutting of the ropes:

1. arr[0](= 5) is cutted into {4, 1}.
2. arr[2](= 7) is cutted into {4, 3}.
3. arr[4](= 9) is cutted into {4, 4, 1}.

After the above combinations of cuts, the maximum length is 4, which is of frequency at least(K = 5).

Input: arr[] = {1, 2, 3, 4, 9}, K = 6
Output: 2

Approach: The given problem can be solved by using the Binary Search. Follow the steps below to solve the problem:

• Initialize 3 variables, say low as 1, high as the maximum value of array arr[], and ans as -1, to store the left boundary right boundary for the binary search and to store the maximum possible length of K ropes.
• Iterate until low is less than or equal to high and perform the following steps:
  • Find the mid-value of the range [low, high] and store it in a variable say mid.
  • Traverse the array arr[] and find the count of ropes of length mid that can be obtained by cutting the ropes and store it in a variable say, count.
  • If the value of count is at least K, then update the value of mid as ans and update the value of low as (mid + 1).
  • Otherwise, update the value of high as (mid – 1).
• After completing the steps, print the value of ans as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the maximum size
// of ropes having frequency at least
// K by cutting the given ropes
int maximumSize(int a[], int k, int n)
{
    // Stores the left and
    // the right boundaries
    int low = 1;
    int high = *max_element(a, a + n);

    // Stores the maximum length
    // of rope possible
    int ans = -1;

    // Iterate while low is less
    // than or equal to high
    while (low <= high) {

        // Stores the mid value of
        // the range [low, high]
        int mid = low + (high - low) / 2;

        // Stores the count of ropes
        // of length mid
        int count = 0;

        // Traverse the array arr[]
        for (int c = 0; c < n; c++) {
            count += a / mid;
        }

        // If count is at least K
        if (count >= k) {

            // Assign mid to ans
            ans = mid;

            // Update the value
            // of low
            low = mid + 1;
        }

        // Otherwise, update the
        // value of high
        else {
            high = mid - 1;
        }
    }

    // Return the value of ans
    return ans;
}

// Driver Code
int main()
{
    int arr[] = { 1, 2, 3, 4, 9 };
    int K = 6;
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << (maximumSize(arr, K, n));
}

// This code is contributed by ukasp

Java

// Java program for the above approach

import java.util.*;

class GFG {

    // Function to find the maximum size
    // of ropes having frequency at least
    // K by cutting the given ropes
    static int maximumSize(Integer[] a,
                           int k)
    {
        // Stores the left and
        // the right boundaries
        int low = 1;
        int high = Collections.max(
            Arrays.asList(a));

        // Stores the maximum length
        // of rope possible
        int ans = -1;

        // Iterate while low is less
        // than or equal to high
        while (low <= high) {

            // Stores the mid value of
            // the range [low, high]
            int mid = low + (high - low) / 2;

            // Stores the count of ropes
            // of length mid
            int count = 0;

            // Traverse the array arr[]
            for (int c = 0;
                 c < a.length; c++) {
                count += a / mid;
            }

            // If count is at least K
            if (count >= k) {

                // Assign mid to ans
                ans = mid;

                // Update the value
                // of low
                low = mid + 1;
            }

            // Otherwise, update the
            // value of high
            else {
                high = mid - 1;
            }
        }

        // Return the value of ans
        return ans;
    }

    // Driver Code
    public static void main(String[] args)
    {
        Integer[] arr = { 1, 2, 3, 4, 9 };
        int K = 6;
        System.out.println(
            maximumSize(arr, K));
    }
}

Python3

# Python program for the above approach

# Function to find the maximum size
# of ropes having frequency at least
# K by cutting the given ropes
def maximumSize(a, k):

    # Stores the left and
    # the right boundaries
    low = 1
    high = max(a)

    # Stores the maximum length
    # of rope possible
    ans = -1

    # Iterate while low is less
    # than or equal to high
    while (low <= high):

        # Stores the mid value of
        # the range [low, high]
        mid = low + (high - low) // 2

        # Stores the count of ropes
        # of length mid
        count = 0

        # Traverse the array arr[]
        for c in range(len(a)):
            count += a // mid


        # If count is at least K
        if (count >= k):

            # Assign mid to ans
            ans = mid

            # Update the value
            # of low
            low = mid + 1

        # Otherwise, update the
        # value of high
        else:
            high = mid - 1

    # Return the value of ans
    return ans

# Driver Code
if __name__ == '__main__':
    arr = [1, 2, 3, 4, 9]
    K = 6
    print(maximumSize(arr, K))

# This code is contributed by mohit kumar 29.

C#

// C# program for the above approach
using System;
using System.Linq;

class GFG{

// Function to find the maximum size
// of ropes having frequency at least
// K by cutting the given ropes
static int maximumSize(int[] a, int k)
{

    // Stores the left and
    // the right boundaries
    int low = 1;
    int high = a.Max();

    // Stores the maximum length
    // of rope possible
    int ans = -1;

    // Iterate while low is less
    // than or equal to high
    while (low <= high)
    {

        // Stores the mid value of
        // the range [low, high]
        int mid = low + (high - low) / 2;

        // Stores the count of ropes
        // of length mid
        int count = 0;

        // Traverse the array []arr
        for(int c = 0;
                c < a.Length; c++)
        {
            count += a / mid;
        }

        // If count is at least K
        if (count >= k)
        {

            // Assign mid to ans
            ans = mid;

            // Update the value
            // of low
            low = mid + 1;
        }

        // Otherwise, update the
        // value of high
        else
        {
            high = mid - 1;
        }
    }

    // Return the value of ans
    return ans;
}

// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 1, 2, 3, 4, 9 };
    int K = 6;

    Console.WriteLine(
        maximumSize(arr, K));
}
}

// This code is contributed by 29AjayKumar

Javascript

<script>
        // Javascript program for the above approach


            // Function to find the maximum size
            // of ropes having frequency at least
            // K by cutting the given ropes
            function maximumSize( a, k) {
            // Stores the left and
            // the right boundaries
            let low = 1;
            let high = Math.max.apply(Math, a);

            // Stores the maximum length
            // of rope possible
            let ans = -1;

            // Iterate while low is less
            // than or equal to high
            while (low <= high) {

                // Stores the mid value of
                // the range [low, high]
                let mid = Math.floor(low + (high - low) / 2);

                // Stores the count of ropes
                // of length mid
                let count = 0;

                // Traverse the array arr[]
                for (let c = 0;
                    c < a.length; c++) {
                    count += Math.floor(a / mid);
                }

                // If count is at least K
                if (count >= k) {

                    // Assign mid to ans
                    ans = mid;

                    // Update the value
                    // of low
                    low = mid + 1;
                }

                // Otherwise, update the
                // value of high
                else {
                    high = mid - 1;
                }
            }

            // Return the value of ans
            return ans;
        }

        // Driver Code

        let arr = [ 1, 2, 3, 4, 9 ];
        let K = 6;
        document.write(maximumSize(arr, K))

        // This code is contributed by Hritik
    </script>

Output:

2

Time Complexity: O(N * log N)
Auxiliary Space: O(1)