Maximum triplets containing atleast one x and one y

Given counts of x, y, and z, the task is to find the maximum number of triplets that can be made from the count of x, y, and z such that one triplet contains at least one x and at least one y. It is not necessary to use all x, y, and z.

Examples:

Input: countX = 2, countY = 1, countZ = 3
Output: 1
Explanation: The first triplet contains one x, one y, and one z.

Input: countX = 3, countY = 4, countZ = 1 
Output: 2
Explanation: The first triplet contains one x, one y, and one z.
The second triplet contains two x and one y.

Approach: To solve the problem follow the below idea:

We can solve this problem using binary search because the range from 0 to min(CountX, CountY) is monotonic increasing. Because our answer lies in this range and can’t be greater than min(CountX, CountY) .

Illustration:

Let take example 2: countX = 3, countY = 4, countZ = 1 

• Min(countX, CountY) = 3. So our search range will be from 0 to 3.
• First, L = 0 and R = 3, mid = 1; we can find that we can make 1 triplet using one x, one y, and one z.so we will move L to mid + 1. Then update our answer to 1.
• Now, L = 2 and R = 3, mid = 2; we can find that we can make 2 triplets using three x, two y, and one z.so we will move L to mid + 1. Then update our answer to 2.
• Now, L = 3 and R = 3, mid = 3; we see that it is not possible to make 3 triplets using 3 counts of x, 4 counts of y, and 1 count of z . so we will move R to mid -1. Then don’t update our answer because the condition is not satisfy.
• Now, L = 3 and R = 2, Since, L > R, our binary search is complete, and the largest possible answer is 2.

Steps were to follow this problem:

• We will apply a binary search whose range is from 0 to min(countX, countY).
• Then Each time find the middle element of the search space.
• If the middle element satisfies a condition we can make a middle number of triplets such that one triplet contains at least one x and at least one y. Then we will update our search range from mid+1 to r ( where r is the last index of the previous search range) and update our answer to mid.
• If the middle element isn’t satisfied a condition that we can’t make a middle number of triplets such that one triplet contains at least one x and at least one y. Then we will update our search range from l to mid-1 ( where l is the firstindex of the previous search range).
• When the binary search is complete, return the answer ( last mid which is satisfying the condition).

Below is the implementation for the above approach:

C++

// C++ implementation of the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find maximum number of
// triplet that we can make using given
// count of x, y and z
int maxTriplets(int x, int y, int z)
{
    int l = 0;

    // Initialize first index of search
    // range to 0
    int r = min(x, y);

    // Initialize last index of search
    // range to min(x, y)
    int ans = 0;

    while (l <= r) {
        int mid = (l + r) / 2;

        // Finding mid of search range

        bool triplet = false;

        // Initially assume, we can not
        // make mid number of triplets
        if (x >= mid and y >= mid)

        // Checking if count of x and y is
        // atleast mid
        {
            int remx = x - mid;

            // x remaining after x mid
            // fixed in mid triplet
            int remy = y - mid;

            // y remaining after y mid
            // fixed in mid triplet

            // Adding extra count x and
            // y and count of z
            int remaining = remx + remy + z;

            if (remaining >= mid)

            // Checking we can make
            // mid no. of triplet
            {
                triplet = true;
            }
        }

        // Checking if we can make mid
        // number of triplet or not
        if (triplet) {

            // If we can make mid number
            // of triplet
            ans = mid;

            // Update our answer
            l = mid + 1;

            // Update search range to
            // [mid+1, R] because we can make
            // atleast mid no. of triplets
        }
        else {
            r = mid - 1;

            // If we can't make mid number
            // of triplet update search range
            // to [l, mid-1] because we can
            // not make mid no. of triplets
        }
    }

    return ans;

    // Return answer
}

// Drive Code
int main()
{
    int x = 2, y = 1, z = 3;

    // Function call for test case 1
    cout << maxTriplets(x, y, z) << "\n";

    x = 3, y = 4, z = 1;

    // Function call for test case 2
    cout << maxTriplets(x, y, z) << "\n";

    return 0;
}

Java

import java.util.*;

public class Main {

  // Function to find maximum number of
  // triplet that we can make using given
  // count of x, y and z
  public static int maxTriplets(int x, int y, int z)
  {
    int l = 0;

    // Initialize first index of search
    // range to 0
    int r = Math.min(x, y);

    // Initialize last index of search
    // range to min(x, y)
    int ans = 0;

    while (l <= r) {
      int mid = (l + r) / 2;

      // Finding mid of search range

      boolean triplet = false;

      // Initially assume, we can not
      // make mid number of triplets
      if (x >= mid && y >= mid)

        // Checking if count of x and y is
        // atleast mid
      {
        int remx = x - mid;

        // x remaining after x mid
        // fixed in mid triplet
        int remy = y - mid;

        // y remaining after y mid
        // fixed in mid triplet

        // Adding extra count x and
        // y and count of z
        int remaining = remx + remy + z;

        if (remaining >= mid)

          // Checking we can make
          // mid no. of triplet
        {
          triplet = true;
        }
      }

      // Checking if we can make mid
      // number of triplet or not
      if (triplet) {

        // If we can make mid number
        // of triplet
        ans = mid;

        // Update our answer
        l = mid + 1;

        // Update search range to
        // [mid+1, R] because we can make
        // atleast mid no. of triplets
      }
      else {
        r = mid - 1;

        // If we can't make mid number
        // of triplet update search range
        // to [l, mid-1] because we can
        // not make mid no. of triplets
      }
    }

    return ans;

    // Return answer
  }

  // Driver Code
  public static void main(String[] args)
  {
    int x = 2, y = 1, z = 3;

    // Function call for test case 1
    System.out.println(maxTriplets(x, y, z));

    x = 3;
    y = 4;
    z = 1;

    // Function call for test case 2
    System.out.println(maxTriplets(x, y, z));
  }
}

C#

// C# implementation of the above approach
using System;

public class GFG {

  // Function to find maximum number of triplet that we
  // can make using given count of x, y and z
  public static int maxTriplets(int x, int y, int z)
  {
    int l = 0;

    // Initialize first index of search range to 0
    int r = Math.Min(x, y);

    // Initialize last index of search range to min(x, y)
    int ans = 0;

    while (l <= r) {
      int mid = (l + r) / 2;

      // Finding mid of search range

      bool triplet = false;

      // Initially assume, we can not make mid number
      // of triplets
      if (x >= mid && y >= mid)

        // Checking if count of x and y is atleast mid
      {
        int remx = x - mid;

        // x remaining after x mid fixed in mid
        // triplet
        int remy = y - mid;

        // y remaining after y mid fixed in mid
        // triplet

        // Adding extra count x and y and count of z
        int remaining = remx + remy + z;

        if (remaining >= mid)

          // Checking we can make mid no. of triplet
        {
          triplet = true;
        }
      }

      // Checking if we can make mid number of triplet
      // or not
      if (triplet) {

        // If we can make mid number of triplet
        ans = mid;

        // Update our answer
        l = mid + 1;

        // Update search range to [mid+1, R] because
        // we can make atleast mid no. of triplets
      }
      else {
        r = mid - 1;

        // If we can't make mid number of triplet
        // update search range to [l, mid-1] because
        // we can not make mid no. of triplets
      }
    }

    return ans;

    // Return answer
  }

  static public void Main()
  {

    // Code
    int x = 2, y = 1, z = 3;

    // Function call for test case 1
    Console.WriteLine(maxTriplets(x, y, z));

    x = 3;
    y = 4;
    z = 1;

    // Function call for test case 2
    Console.WriteLine(maxTriplets(x, y, z));
  }
}

// This code is contribtuted by sankar.

Python3

# Python3 implementation of the above approachprint("GFG")

# Function to find maximum number of
# triplet that we can make using given
# count of x, y and z
def maxTriplets(x: int, y: int, z: int) -> int:
    # Initialize first index of search range to 0
    l = 0

    # Initialize last index of search range to min(x, y)
    r = min(x, y)

    # Initialize answer to 0
    ans = 0

    # Binary search loop
    while l <= r:
        # Finding mid of search range
        mid = (l + r) // 2

        # Initially assume, we can not make mid number of triplets
        triplet = False

        # Checking if count of x and y is atleast mid
        if x >= mid and y >= mid:
            # x remaining after x mid fixed in mid triplet
            remx = x - mid

            # y remaining after y mid fixed in mid triplet
            remy = y - mid

            # Adding extra count x and y and count of z
            remaining = remx + remy + z

            # Checking we can make mid no. of triplet
            if remaining >= mid:
                triplet = True

        # Checking if we can make mid number of triplet or not
        if triplet:
            # If we can make mid number of triplet
            ans = mid

            # Update search range to [mid+1, R] because we can make
            # atleast mid no. of triplets
            l = mid + 1
        else:
            # If we can't make mid number of triplet update search range
            # to [l, mid-1] because we can not make mid no. of triplets
            r = mid - 1

    # Return the answer
    return ans


# Driver Code
if __name__ == '__main__':
    x = 2
    y = 1
    z = 3

    # Function call for test case 1
    print(maxTriplets(x, y, z))

    x = 3
    y = 4
    z = 1

    # Function call for test case 2
    print(maxTriplets(x, y, z))

Javascript

// JavaScript implementation of the above approachprint("GFG")

// Function to find maximum number of
// triplet that we can make using given
// count of x, y and z
function maxTriplets(x, y, z) {
  let l = 0;

  // Initialize first index of search
  // range to 0
  let r = Math.min(x, y);

  // Initialize last index of search
  // range to min(x, y)
  let ans = 0;

  while (l <= r) {
    let mid = Math.floor((l + r) / 2);

    // Finding mid of search range

    let triplet = false;

    // Initially assume, we can not
    // make mid number of triplets
    if (x >= mid && y >= mid)

    // Checking if count of x and y is
    // at least mid
    {
      let remx = x - mid;

      // x remaining after x mid
      // fixed in mid triplet
      let remy = y - mid;

      // y remaining after y mid
      // fixed in mid triplet

      // Adding extra count x and
      // y and count of z
      let remaining = remx + remy + z;

      if (remaining >= mid)

      // Checking we can make
      // mid no. of triplet
      {
        triplet = true;
      }
    }

    // Checking if we can make mid
    // number of triplet or not
    if (triplet) {

      // If we can make mid number
      // of triplet
      ans = mid;

      // Update our answer
      l = mid + 1;

      // Update search range to
      // [mid+1, R] because we can make
      // at least mid no. of triplets
    } else {
      r = mid - 1;

      // If we can't make mid number
      // of triplet update search range
      // to [l, mid-1] because we can
      // not make mid no. of triplets
    }
  }

  return ans;

  // Return answer
}

// Driver Code
let x = 2,
  y = 1,
  z = 3;

// Function call for test case 1
console.log(maxTriplets(x, y, z));

x = 3, y = 4, z = 1;

// Function call for test case 2
console.log(maxTriplets(x, y, z));

Output

1
2

Time Complexity: O(log₂n)
Auxiliary Space: O(1)

Efficient Approach: We can also solve this problem efficiently by making these observations:

• We can see that the maximum number of triplets can be made that contain at least one x and one y can’t be greater than the minimum count of x and y. 
• If the count of z is greater than or equal to the minimum(count of x, count of y). So our answer will be minimum(count of x, count of y) because we have used our all x or y in making ‘a’ number of triplets where an equal to the minimum( count of x, count of y).
• If the count of z is less than the minimum(count of x, count of y), then our answer will be less than the minimum of the count of x and y and the answer will be the sum no. of triplets can be made using the count of x, y and z and no. of triplets that can be made using the count of x and y only such that one triplet contain at least one x and at least one y.
• Finally, return our final answer.

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 number of
// triplets can be made that contain
// least one x and one y
int maxTriplets(int x, int y, int z)
{
    int mi = min(x, y), ans;

    if (mi <= z)

    // If min(x, y) less than or equal to
    // count of z
    // Then triplets can be made at
    // most min(x, y)
    {
        ans = mi;
    }
    else

    // If min(x, y) greater than count of z
    {
        ans = z;

        // Then first we add z to our
        // answer because we
        x -= z;

        // can make atleast count
        // of z triplet
        y -= z;

        // Using all count of z

        mi = min(x, y);

        // min(x, y), after making count
        // of z triplets
        int ma = max(x, y);

        // max(x, y), after making count
        // of z triplets
        if (mi * 2 <= ma) {

            // If 2 times of min <= ma, so
            // we can make at most mi
            // triplets using count of
            // x and y only.
            // In mi*2 <= ma, we can't use
            // all count of x and y.
            ans += mi;
        }
        else {

            // Otherwise we can make (mi+ma)/3
            // triplet using count of x and y
            // only because if mi*2>ma we can
            // make triplet using all x and y
            ans += (mi + ma) / 3;
        }
    }
    return ans;

    // Return final answer
}

// Driver's code
int main()
{
    int x = 2, y = 1, z = 3;

    // Function call for test case 1
    cout << maxTriplets(x, y, z) << "\n";

    x = 3, y = 4, z = 1;

    // Function call for test case 2
    cout << maxTriplets(x, y, z) << "\n";

    return 0;
}

Java

// Java program for the above approach

import java.util.*;

class GFG {

    // Function to find the maximum number of triplets can be made that contain
    // least one x and one y
    public static int maxTriplets(int x, int y, int z) {
        int mi = Math.min(x, y), ans;

        if (mi <= z)

            // If min(x, y) less than or equal to
            // count of z
            // Then triplets can be made at
            // most min(x, y)
            ans = mi;
        else

        // If min(x, y) greater than count of z
        {
            ans = z;

            // Then first we add z to our
            // answer because we
            x -= z;

            // can make at least count
            // of z triplet
            y -= z;

            // Using all count of z

            mi = Math.min(x, y);

            // min(x, y), after making count
            // of z triplets
            int ma = Math.max(x, y);

            // max(x, y), after making count
            // of z triplets
            if (mi * 2 <= ma) {

                // If 2 times of min <= ma, so
                // we can make at most mi
                // triplets using count of
                // x and y only.
                // In mi*2 <= ma, we can't use
                // all count of x and y.
                ans += mi;
            } else {

                // Otherwise we can make (mi+ma)/3
                // triplet using count of x and y
                // only because if mi*2>ma we can
                // make triplet using all x and y
                ans += (mi + ma) / 3;
            }
        }
        return ans;
        // Return final answer
    }

    // Driver's code
    public static void main(String[] args) {
        int x = 2, y = 1, z = 3;

        // Function call for test case 1
        System.out.println(maxTriplets(x, y, z));

        x = 3;
        y = 4;
        z = 1;

        // Function call for test case 2
        System.out.println(maxTriplets(x, y, z));
    }
}

Python3

# Java program for the above approach

# Function to find the maximum number of triplets can be made that contain
# least one x and one y
def maxTriplets(x, y, z):
    mi = min(x, y)
    ans = 0
    if mi <= z:
        # If min(x, y) less than or equal to
        # count of z
        # Then triplets can be made at
        # most min(x, y)
        ans = mi
    else:
        # If min(x, y) greater than count of z
        ans = z
        # Then first we add z to our answer
        # because we can make atleast count of z triplet
        x -= z
        y -= z
        # Using all count of z
        mi = min(x, y)
        # min(x, y), after making count of z triplets
        ma = max(x, y)
        # max(x, y), after making count of z triplets
        if mi * 2 <= ma:
            # If 2 times of min <= ma, so
            # we can make at most mi
            # triplets using count of x and y only.
            # In mi*2 <= ma, we can't use all count of x and y.
            ans += mi
        else:
            # Otherwise we can make (mi+ma)/3
            # triplet using count of x and y
            # only because if mi*2>ma we can
            # make triplet using all x and y
            ans += (mi + ma) // 3
    return ans

# Driver's code
x, y, z = 2, 1, 3
# Function call for test case 1
print(maxTriplets(x, y, z))

x, y, z = 3, 4, 1
# Function call for test case 2
print(maxTriplets(x, y, z))

C#

// C# program for the above approach

using System;

namespace MaxTriplets
{
    class GFG
    {
        // Function to find the maximum number of triplets
        // that can be made that contain at least one x and one y
        static int maxTriplets(int x, int y, int z)
        {
            int mi = Math.Min(x, y);
            int ans;

            if (mi <= z)
            {
                // If min(x, y) is less than or equal to
                // count of z, then triplets can be made at
                // most min(x, y)
                ans = mi;
            }
            else
            {
                // If min(x, y) is greater than count of z
                ans = z;

                // Then first we add z to our answer because we
                // can make at least count of z triplet
                x -= z; // Using all count of z
                y -= z;

                mi = Math.Min(x, y); // min(x, y), after making count of z triplets
                int ma = Math.Max(x, y); // max(x, y), after making count of z triplets

                if (mi * 2 <= ma)
                {
                    // If 2 times of min <= ma, so we can make at most mi
                    // triplets using count of x and y only.
                    // In mi*2 <= ma, we can't use all count of x and y.
                    ans += mi;
                }
                else
                {
                    // Otherwise we can make (mi+ma)/3 triplet using count of x and y
                    // only because if mi*2>ma we can make triplet using all x and y
                    ans += (mi + ma) / 3;
                }
            }
            return ans;
        }

        // Driver code
        static void Main(string[] args)
        {
            int x = 2, y = 1, z = 3;

            // Function call for test case 1
            Console.WriteLine(maxTriplets(x, y, z));

            x = 3; y = 4; z = 1;

            // Function call for test case 2
            Console.WriteLine(maxTriplets(x, y, z));
        }
    }
}

Javascript

// Javascript program for the above approach

// Function to find the maximum number of
// triplets can be made that contain
// least one x and one y
function maxTriplets(x, y, z)
{
    let mi = Math.min(x, y), ans;

    if (mi <= z) {
        // If min(x, y) less than or equal to
        // count of z
        // Then triplets can be made at
        // most min(x, y)
        ans = mi;
    }
    else {
        // If min(x, y) greater than count of z
        ans = z;

        // Then first we add z to our answer
        // because we can make atleast count
        // of z triplet
        x -= z;
        y -= z;

        // Using all count of z
        mi = Math.min(x, y);

        // min(x, y), after making count
        // of z triplets
        let ma = Math.max(x, y);

        // max(x, y), after making count
        // of z triplets
        if (mi * 2 <= ma) {
            // If 2 times of min <= ma, so
            // we can make at most mi
            // triplets using count of
            // x and y only.
            // In mi*2 <= ma, we can't use
            // all count of x and y.
            ans += mi;
        }
        else {
            // Otherwise we can make (mi+ma)/3
            // triplet using count of x and y
            // only because if mi*2>ma we can
            // make triplet using all x and y
            ans += Math.floor((mi + ma) / 3);
        }
    }
    return ans;
    // Return final answer
}

// Driver's code
let x = 2, y = 1, z = 3;

// Function call for test case 1
console.log(maxTriplets(x, y, z));

x = 3, y = 4, z = 1;

// Function call for test case 2
console.log(maxTriplets(x, y, z));

Output

1
2

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