Maximum number of mangoes that can be bought

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)