Verifique si las 3 bolsas de dulces se pueden vaciar quitando 2 dulces de cualquier bolsa y 1 de las otras dos repetidamente

Dados 3 números enteros a, b y c que indican el número de dulces presentes en tres bolsas. Debe averiguar si podemos vaciar todas las bolsas realizando una operación específica en la que, en cada operación, puede comer 2 dulces de una bolsa y 1 dulce cada uno de las otras 2 bolsas. No está permitido saltear ninguna bolsa, es decir, se deben comer 1 o 2 dulces de cada bolsa en cada operación. Devuelve verdadero si es posible, de lo contrario, devuelve falso.

Ejemplos:

Entrada: 4, 2, 2
Salida: verdadero
Explicación: 
Operación 1 : puedes comer 2 dulces de la bolsa 1 y 1 de la bolsa 2 y de la bolsa 3 cada uno.
Caramelos que quedan después de la operación 1
bolsa1 = 2, bolsa2 = 1, bolsa3 = 1
Operación 2: puedes comer 2 caramelos de la bolsa1 y 1 de cada bolsa2 y cada bolsa3
Caramelos que quedan después de la operación 2
bolsa1 = 0, bolsa2 = 0, bolsa3 = 0
Por lo tanto, es posible vaciar todas las bolsas.

Entrada: 3, 4, 2
Salida: falso

Enfoque ingenuo: iterar a través de las variables hasta que las tres no se conviertan en 0. En cada iteración, reduzca el elemento máximo en 2 y las variables restantes en 1.

Complejidad temporal: O(N), donde N es el valor de la variable máxima de a, b y c

Enfoque eficiente : el problema dado se puede resolver con el enfoque eficiente haciendo las siguientes observaciones:

• En cada operación sacaremos 1+2+1=4 caramelos, por lo que la suma de todos los caramelos de la bolsa1, la bolsa2 y la bolsa3 debe ser divisible por 4 .
• El número de operaciones requeridas para vaciar todas las bolsas sería (suma de todos los dulces)/4 .
• Tenemos que sacar 1 o 2 caramelos de una bolsa en cualquier operación, por lo que el mínimo de caramelos presentes de las 3 bolsas debe ser mayor o igual al número de operaciones.

// C++ code for the above approach
 
#include <bits/stdc++.h>
#define ll long long
using namespace std;
 
bool can_empty(ll a, ll b, ll c)
{
    // If total candies are not multiple
    // of 4 then its not possible to be
    // left with 0 candies
    if ((a + b + c) % 4 != 0)
        return false;
    else {
 
        // If minimum candies of three bags
        // are less than number of operations
        // required then the task is not possible
        int m = min(a, min(b, c));
        if (m < ((a + b + c) / 4))
            return false;
    }
    return true;
}
 
// Driver code
int main()
{
    ll a = 4, b = 2, c = 2;
    cout << (can_empty(a, b, c) ? "true" : "false")
         << endl;
 
    a = 3, b = 4, c = 2;
    cout << (can_empty(a, b, c) ? "true" : "false")
         << endl;
 
    return 0;
}

// Java code for the above approach
import java.util.*;
 
class GFG{
 
static boolean can_empty(int a, int b, int c)
{
     
    // If total candies are not multiple
    // of 4 then its not possible to be
    // left with 0 candies
    if ((a + b + c) % 4 != 0)
        return false;
    else
    {
         
        // If minimum candies of three bags
        // are less than number of operations
        // required then the task is not possible
        int m = Math.min(a, Math.min(b, c));
        if (m < ((a + b + c) / 4))
            return false;
    }
    return true;
}
   
// Driver Code
public static void main(String[] args)
{
    int a = 4, b = 2, c = 2;
    System.out.println(can_empty(a, b, c) ?
                       "true" : "false");
 
    a = 3;
    b = 4;
    c = 2;
    System.out.println(can_empty(a, b, c) ?
                       "true" : "false");
}
}
 
// This code is contributed by code_hunt

# Python code for the above approach
def can_empty(a, b, c):
     
    # If total candies are not multiple
    # of 4 then its not possible to be
    # left with 0 candies
    if ((a + b + c) % 4 != 0) :
        return False;
    else :
         
        # If minimum candies of three bags
        # are less than number of operations
        # required then the task is not possible
        m = min(a, min(b, c));
        if (m < (a + b + c) // 4) :
            return False;
     
    return True;
 
# Driver code
a = 4
b = 2
c = 2
print("true" if can_empty(a, b, c) else "false");
 
a = 3
b = 4
c = 2
print("true" if can_empty(a, b, c) else "false");
 
# This code is contributed by _saurabh_jaiswal

using System;
 
public class GFG {
    static bool can_empty(int a, int b, int c)
    {
 
        // If total candies are not multiple
        // of 4 then its not possible to be
        // left with 0 candies
        if ((a + b + c) % 4 != 0)
            return false;
        else {
 
            // If minimum candies of three bags
            // are less than number of operations
            // required then the task is not possible
            int m = Math.Min(a, Math.Min(b, c));
            if (m < ((a + b + c) / 4))
                return false;
        }
        return true;
    }
 
    // Driver Code
    static public void Main()
    {
        int a = 4, b = 2, c = 2;
        Console.WriteLine(can_empty(a, b, c) ? "true"
                                              : "false");
 
        a = 3;
        b = 4;
        c = 2;
        Console.WriteLine(can_empty(a, b, c) ? "true"
                                              : "false");
    }
}
 
// This code is contributed by maddler.

<script>
 
// Javascript code for the above approach
function can_empty(a, b, c)
{
     
    // If total candies are not multiple
    // of 4 then its not possible to be
    // left with 0 candies
    if ((a + b + c) % 4 != 0)
        return false;
    else
    {
         
        // If minimum candies of three bags
        // are less than number of operations
        // required then the task is not possible
        let m = Math.min(a, Math.min(b, c));
        if (m < Math.floor((a + b + c) / 4))
            return false;
    }
    return true;
}
 
// Driver code
let a = 4,
b = 2,
c = 2;
document.write(can_empty(a, b, c) ? "true" : "false");
document.write("<br>");
 
(a = 3), (b = 4), (c = 2);
document.write(can_empty(a, b, c) ? "true" : "false");
 
// This code is contributed by _saurabh_jaiswal
 
</script>

true
false

Complejidad de tiempo: O(1)
Complejidad de espacio: O(1)