Maximum number of objects that can be created as per given conditions

Given N items of type-1 and M items of type-2. An object can be created from 2 items of type-1 and 1 item of type-2 or 2 items of type-2 and 1 item of type-1 pieces. The task is to find the maximum number of objects that can be created from given number of items of each type.
Examples:

Input: N = 8, M = 7 
Output: 5 
Explanation:
3 pairs of 2 type-1 and 1 type-2 objects. 
2 pairs of 1 type-1 and 2 type-2 objects.
Input: N = 20, M = 3 
Output: 3 
Explanation:
3 pairs of 2 type-1 and 1 type-2 objects. 

Approach:
Follow the steps below to solve the problem: 

• Create two variables initial and final.
• initial = Minimum of N, M.
• final = Divide N + M by 3 ( as an object is made up of 3 components).
• Minimum of initial and final is maximum number of objects that can be created from given N type-1 and M type-2 items.

Below is the implementation of the above approach: 

C++

// C++ program for the above problem
#include <bits/stdc++.h>
using namespace std;

// Function for finding
// the maximum number of
// objects from N type-1 and
// M type-2 items

int numberOfObjects(int N, int M)
{
    // storing minimum of N and M
    int initial = min(N, M);

    // storing maximum number of
    // objects from given items
    int final = (N + M) / 3;

    return min(initial, final);
}

// Driver Code
int main()
{
    int N = 8;
    int M = 7;
    cout << numberOfObjects(N, M)
         << endl;
    return 0;
}

Java

// Java program for the above problem
class GFG{

// Function for finding
// the maximum number of
// objects from N type-1 and
// M type-2 items
static int numberOfObjects(int N, int M)
{

    // Storing minimum of N and M
    int initial = Math.min(N, M);

    // Storing maximum number of
    // objects from given items
    int last = (N + M) / 3;

    return Math.min(initial, last);
}

// Driver Code
public static void main(String[] args)
{
    int N = 8;
    int M = 7;

    System.out.println(numberOfObjects(N, M));
}
}

// This code is contributed by rutvik_56

Python3

# Python3 program for the above problem

# Function for finding
# the maximum number of
# objects from N type-1 and
# M type-2 items
def numberOfObjects(N, M):

    # Storing minimum of N and M
    initial = min(N, M)

    # Storing maximum number of
    # objects from given items
    final = (N + M) // 3

    return min(initial, final)

# Driver Code
if __name__ == '__main__':

    N = 8
    M = 7

    print(numberOfObjects(N, M))

# This code is contributed by mohit kumar 29

C#

// C# program for the above problem
using System;
class GFG{

// Function for finding
// the maximum number of
// objects from N type-1 and
// M type-2 items
static int numberOfObjects(int N, int M)
{

    // Storing minimum of N and M
    int initial = Math.Min(N, M);

    // Storing maximum number of
    // objects from given items
    int last = (N + M) / 3;

    return Math.Min(initial, last);
}

// Driver Code
public static void Main(string[] args)
{
    int N = 8;
    int M = 7;

    Console.Write(numberOfObjects(N, M));
}
}

// This code is contributed by rock_cool

Javascript

<script>
// JavaScript program for the above problem

// Function for finding
// the maximum number of
// objects from N type-1 and
// M type-2 items
function numberOfObjects(N, M)
{

    // storing minimum of N and M
    let initial = Math.min(N, M);

    // storing maximum number of
    // objects from given items
    let final = Math.floor((N + M) / 3);
    return Math.min(initial, final);
}

// Driver Code
    let N = 8;
    let M = 7;
    document.write(numberOfObjects(N, M)
        + "<br>");

// This code is contributed by Surbhi Tyagi.
</script>

Output:

5

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