Skip to content
Related Articles

Related Articles

Improve Article

Maximum number of mangoes that can be bought

  • Difficulty Level : Easy
  • Last Updated : 30 Jun, 2021

Given two integers W and C, representing the number of watermelons and coins, the task is to find the maximum number of mangoes that can be bought given that each mango costs 1 watermelon and X coins and y coins can be earned selling a watermelon.

Examples:

Input: W = 10, C = 10, X = 1, Y = 1
Output: 10
Explanation: The most optimal way is to use 10 watermelons and 10 coins to buy 10 mangoes. Hence, the maximum number of mangoes that can be bought is 10.

Input: W = 4, C = 8, X = 4, Y = 4
Output: 3
Explanation: The most optimal way is to sell one watermelon. Then, the number of coins increases by 4. Therefore, the total number of coins becomes 12. Therefore, 3 watermelons and 12 coins can be used to buy 3 mangoes. Hence, the maximum number of mangoes that can be bought is 3.

Approach: This problem can be solved using binary search. The idea is to find the maximum number of mangoes in the search space. Follow the steps below to solve the problem:



  • Initialize a variable ans as 0 to store the required result.
  • Initialize two variables l as 0, r as W to store the boundary regions of the search space for binary search.
  • Loop while l≤r and perform the following steps:
    • Store the middle value in a variable mid as (l+r)/2.
    • Check if mid number of mangoes can be bought using the given value of W, C, x, and y.
    • If true, then update ans to mid and search in the right part of mid by updating l to mid+1. Otherwise, update the value of r to mid-1.
  • Print the value of ans as the result.

Below is the implementation of the above approach:

C++14




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if mid number
// of mangoes can be bought
bool check(int n, int m, int x, int y, int vl)
{
    // Store the coins
    int temp = m;
 
    // If watermelons needed are greater
    // than given watermelons
    if (vl > n)
        return false;
 
    // Store remaining watermelons if vl
    // watermelons are used to buy mangoes
    int ex = n - vl;
 
    // Store the value of coins if these
    // watermelon get sold
    ex *= y;
 
    // Increment coins by ex
    temp += ex;
 
    // Number of mangoes that can be buyed
    // if only x coins needed for one mango
    int cr = temp / x;
 
    // If the condition is satisfied,
    // return true
    if (cr >= vl)
        return true;
 
    // Otherwise return false
    return false;
}
 
// Function to find the maximum number of mangoes
// that can be bought by selling watermelons
int maximizeMangoes(int n, int m, int x, int y)
{
    // Initialize the boundary values
    int l = 0, r = n;
 
    // Store the required result
    int ans = 0;
 
    // Binary Search
    while (l <= r) {
 
        // Store the mid value
        int mid = l + (r - l) / 2;
 
        // Check if it is possible to
        // buy mid number of mangoes
        if (check(n, m, x, y, mid)) {
            ans = mid;
            l = mid + 1;
        }
 
        // Otherwise, update r to mid -1
        else
            r = mid - 1;
    }
 
    // Return the result
    return ans;
}
 
// Driver Code
int main()
{
    // Given Input
    int W = 4, C = 8, x = 4, y = 4;
 
    // Function Call
    cout << maximizeMangoes(W, C, x, y);
 
    return 0;
}

Java




// Java program for the above approach
class GFG{
 
// Function to check if mid number
// of mangoes can be bought
static boolean check(int n, int m, int x,
                     int y, int vl)
{
     
    // Store the coins
    int temp = m;
 
    // If watermelons needed are greater
    // than given watermelons
    if (vl > n)
        return false;
 
    // Store remaining watermelons if vl
    // watermelons are used to buy mangoes
    int ex = n - vl;
 
    // Store the value of coins if these
    // watermelon get sold
    ex *= y;
 
    // Increment coins by ex
    temp += ex;
 
    // Number of mangoes that can be buyed
    // if only x coins needed for one mango
    int cr = temp / x;
 
    // If the condition is satisfied,
    // return true
    if (cr >= vl)
        return true;
 
    // Otherwise return false
    return false;
}
 
// Function to find the maximum number
// of mangoes that can be bought by
// selling watermelons
static int maximizeMangoes(int n, int m,
                           int x, int y)
{
     
    // Initialize the boundary values
    int l = 0, r = n;
 
    // Store the required result
    int ans = 0;
 
    // Binary Search
    while (l <= r)
    {
         
        // Store the mid value
        int mid = l + (r - l) / 2;
 
        // Check if it is possible to
        // buy mid number of mangoes
        if (check(n, m, x, y, mid))
        {
            ans = mid;
            l = mid + 1;
        }
 
        // Otherwise, update r to mid -1
        else
            r = mid - 1;
    }
 
    // Return the result
    return ans;
}
 
// Driver code
public static void main(String[] args)
{
     
    // Given Input
    int W = 4, C = 8, x = 4, y = 4;
 
    // Function Call
    System.out.println(maximizeMangoes(W, C, x, y));
}
}
 
// This code is contributed by abhinavjain194

Python3




# Python3 program for the above approach
 
# Function to check if mid number
# of mangoes can be bought
def check(n, m, x, y, vl):
     
    # Store the coins
    temp = m
 
    # If watermelons needed are greater
    # than given watermelons
    if (vl > n):
        return False
 
    # Store remaining watermelons if vl
    # watermelons are used to buy mangoes
    ex = n - vl
 
    # Store the value of coins if these
    # watermelon get sold
    ex *= y
 
    # Increment coins by ex
    temp += ex
 
    # Number of mangoes that can be buyed
    # if only x coins needed for one mango
    cr = temp // x
 
    # If the condition is satisfied,
    # return true
    if (cr >= vl):
        return True
 
    # Otherwise return false
    return False
 
# Function to find the maximum number of mangoes
# that can be bought by selling watermelons
def maximizeMangoes(n, m, x, y):
     
    # Initialize the boundary values
    l = 0
    r = n
 
    # Store the required result
    ans = 0
 
    # Binary Search
    while (l <= r):
 
        # Store the mid value
        mid = l + (r - l) // 2
 
        # Check if it is possible to
        # buy mid number of mangoes
        if (check(n, m, x, y, mid)):
            ans = mid
            l = mid + 1
 
        # Otherwise, update r to mid -1
        else:
            r = mid - 1
 
    # Return the result
    return ans
 
# Driver Code
if __name__ == '__main__':
     
    # Given Input
    W = 4
    C = 8
    x = 4
    y = 4
 
    # Function Call
    print(maximizeMangoes(W, C, x, y))
     
# This code is contributed by bgangwar59

C#




// C# program for the above approach
using System;
 
class GFG{
 
// Function to check if mid number
// of mangoes can be bought
static bool check(int n, int m, int x,
                  int y, int vl)
{
     
    // Store the coins
    int temp = m;
 
    // If watermelons needed are greater
    // than given watermelons
    if (vl > n)
        return false;
 
    // Store remaining watermelons if vl
    // watermelons are used to buy mangoes
    int ex = n - vl;
 
    // Store the value of coins if these
    // watermelon get sold
    ex *= y;
 
    // Increment coins by ex
    temp += ex;
 
    // Number of mangoes that can be buyed
    // if only x coins needed for one mango
    int cr = temp / x;
 
    // If the condition is satisfied,
    // return true
    if (cr >= vl)
        return true;
 
    // Otherwise return false
    return false;
}
 
// Function to find the maximum number of mangoes
// that can be bought by selling watermelons
static int maximizeMangoes(int n, int m, int x, int y)
{
     
    // Initialize the boundary values
    int l = 0, r = n;
 
    // Store the required result
    int ans = 0;
 
    // Binary Search
    while (l <= r)
    {
         
        // Store the mid value
        int mid = l + (r - l) / 2;
 
        // Check if it is possible to
        // buy mid number of mangoes
        if (check(n, m, x, y, mid))
        {
            ans = mid;
            l = mid + 1;
        }
 
        // Otherwise, update r to mid -1
        else
            r = mid - 1;
    }
 
    // Return the result
    return ans;
}
 
// Driver Code
public static void Main()
{
     
    // Given Input
    int W = 4, C = 8, x = 4, y = 4;
 
    // Function Call
    Console.Write(maximizeMangoes(W, C, x, y));
}
}
                
// This code is contributed by ukasp

Javascript




<script>
// Javascript program for the above approach
 
// Function to check if mid number
// of mangoes can be bought
function check(n, m,  x, y,vl)
{
    // Store the coins
    var temp = m;
 
    // If watermelons needed are greater
    // than given watermelons
    if (vl > n)
        return false;
 
    // Store remaining watermelons if vl
    // watermelons are used to buy mangoes
    var ex = n - vl;
 
    // Store the value of coins if these
    // watermelon get sold
    ex *= y;
 
    // Increment coins by ex
    temp += ex;
 
    // Number of mangoes that can be buyed
    // if only x coins needed for one mango
    var cr = parseInt(temp / x);
 
    // If the condition is satisfied,
    // return true
    if (cr >= vl)
        return true;
 
    // Otherwise return false
    return false;
}
 
// Function to find the maximum number of mangoes
// that can be bought by selling watermelons
function maximizeMangoes(n, m, x, y)
{
    // Initialize the boundary values
    var l = 0, r = n;
 
    // Store the required result
    var ans = 0;
 
    // Binary Search
    while (l <= r) {
 
        // Store the mid value
        var mid = l + parseInt((r - l) / 2);
 
        // Check if it is possible to
        // buy mid number of mangoes
        if (check(n, m, x, y, mid)) {
            ans = mid;
            l = mid + 1;
        }
 
        // Otherwise, update r to mid -1
        else
            r = mid - 1;
    }
 
    // Return the result
    return ans;
}
var W = 4, C = 8, x = 4, y = 4;
 
// Function Call
document.write( maximizeMangoes(W, C, x, y));
 
//This code is contributed by SoumikMondal
</script>
Output: 
3

 

Time Complexity: O(log(W))
Auxiliary Space: O(1)

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :