Maximice el conteo de 001 y 110 que se pueden formar usando M 0 y N 1

Dados dos números enteros N (que indica el número de ‘1’) y M (que indica el número de ‘0’). La tarea es maximizar la cantidad de patrones «001» o «110» que se pueden formar usando la cantidad dada de caracteres.

Ejemplos: 

Entrada:  N = 5, M = 5
Salida: 3
Explicación: Los patrones posibles son {001, 110, 001}

Entrada: N = 7, M = 10
Salida: 5

Enfoque: Este problema se puede resolver dividiendo todo el problema en casos. Siga los pasos a continuación para resolver el problema dado. 

• Si N/2 >= M entonces solo se formarán 001 patrones y el número máximo de patrones en tal caso será M .
• Si M/2 >= N entonces solo se formarán 110 patrones y el número máximo de patrones en tal caso será N .
• De lo contrario, si abs(NM) < 2*min(N, M), en ese caso se emitirá (N+M)/3 .
• Imprima el resultado de acuerdo con las condiciones anteriores.

A continuación se muestra la implementación del enfoque anterior: 

// C++ code to implement above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum
// possible patterns that can be formed
int geeksforgeeks(int N, int M)
{
    // To store the number of patterns
    // formed by using 0 and 1
    int ans = 0;
    if ((N / 2) >= M) {
        ans = M;
    }
    else if ((M / 2) >= N) {
        ans = N;
    }
    else {
        ans = (N + M) / 3;
    }
    return ans;
}
 
// Driver Code
int main()
{
    int N, M;
    N = 7;
    M = 10;
 
    // Function call
    cout << geeksforgeeks(N, M);
    return 0;
}

// Java program for the above approach
class GFG {
 
    // Function to find the maximum
    // possible patterns that can be formed
    static int geeksforgeeks(int N, int M) {
 
        // To store the number of patterns
        // formed by using 0 and 1
        int ans = 0;
        if ((N / 2) >= M) {
            ans = M;
        } else if ((M / 2) >= N) {
            ans = N;
        } else {
            ans = (N + M) / 3;
        }
        return ans;
    }
 
    // Driver Code
    public static void main(String args[]) {
        int N, M;
        N = 7;
        M = 10;
 
        // Function call
        System.out.println(geeksforgeeks(N, M));
    }
}
 
// This code is contributed by gfgking

# Python 3 code to implement above approach
 
# Function to find the maximum
# possible patterns that can be formed
def geeksforgeeks(N,  M):
 
    # To store the number of patterns
    # formed by using 0 and 1
    ans = 0
    if ((N // 2) >= M):
        ans = M
 
    elif ((M // 2) >= N):
        ans = N
 
    else:
        ans = (N + M) // 3
 
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    N = 7
    M = 10
 
    # Function call
    print(geeksforgeeks(N, M))
 
    # This code is contributed by ukasp.

// C# program for the above approach
using System;
class GFG
{
 
  // Function to find the maximum
  // possible patterns that can be formed
  static int geeksforgeeks(int N, int M)
  {
 
    // To store the number of patterns
    // formed by using 0 and 1
    int ans = 0;
    if ((N / 2) >= M) {
      ans = M;
    }
    else if ((M / 2) >= N) {
      ans = N;
    }
    else {
      ans = (N + M) / 3;
    }
    return ans;
  }
 
  // Driver Code
  public static void Main()
  {
    int N, M;
    N = 7;
    M = 10;
     
    // Function call
    Console.Write(geeksforgeeks(N, M));
 
  }
}
 
// This code is contributed by Samim Hossain Mondal.

<script>
       // JavaScript code for the above approach
 
       // Function to find the maximum
       // possible patterns that can be formed
       function geeksforgeeks(N, M)
       {
        
           // To store the number of patterns
           // formed by using 0 and 1
           let ans = 0;
           if (Math.floor(N / 2) >= M) {
               ans = M;
           }
           else if (Math.floor(M / 2) >= N) {
               ans = N;
           }
           else {
               ans = Math.floor((N + M) / 3);
           }
           return ans;
       }
 
       // Driver Code
       let N, M;
       N = 7;
       M = 10;
 
       // Function call
       document.write(geeksforgeeks(N, M));
 
 // This code is contributed by Potta Lokesh
   </script>

5

Tiempo Complejidad: O(1)
Espacio Auxiliar: O(1)