Encuentra el número mínimo y máximo de términos para dividir N como suma de 4 o 6

Dado un número entero N , la tarea es encontrar el número mínimo y máximo de términos necesarios para dividir N como la suma de 4 o 6.

Ejemplos:

Entrada: N = 3
Salida: IMPOSIBLE
Explicación: Como el número es menor que 4, no es posible.

Entrada: N = 10 
Salida: Términos mínimos = 2, Términos máximos = 2
Explicación: Solo hay una división posible (4 + 6).

Enfoque: El problema se puede resolver con base en la siguiente observación matemática:

Si N se puede expresar en términos de 4 y 6, entonces la respuesta debe estar cerca de N/6 para los términos mínimos y cerca de N/4 para los términos máximos.
Si N%6 deja un resto 2, se puede reemplazar por dos 4 y si N%6 deja un resto 4, se puede agregar un 4.
Si N%4 deja un resto 2, entonces puede ser reemplazado por un 6. 

Siga los pasos mencionados a continuación para implementar la idea:

• Inicialice dos variables (digamos maxi y mini ) con N/4 y N/6 respectivamente para almacenar el número máximo y mínimo de términos.
• N%4 podría ser 0, 1, 2 o 3.
  • Si es 1 o 3, no podemos representar esta serie con las medias de 4.
  • Si N%4 es 2, entonces el último término de la serie, es decir, 4 se combinará con este 2 para formar 6. Por lo tanto, podemos representar la serie con el uso de 4 o 6.
• De manera similar, N%6 puede ser 0, 1, 2, 3, 4, 5. 
  • Si es 1, 3 o 5, no podemos representar esta serie con las medias de 6.
  • Si N%6 es 2, entonces el último término de la serie, es decir, 6 se combinará con este 2 para formar 8, que además se puede dividir en dos partes de 4.
  • Si N%6 es 4, simplemente aumente el mini en uno, ya que se puede usar 4 para representar la serie.
• Devuelve el mínimo y el máximo calculados de esta forma.

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

// C++ code to implement the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum
// and the maximum terms
pair<int, int> checkdivisibilityby4and6(int n)
{
    // Edge case
    if (n < 4)
        return { -1, -1 };
    int maxi, mini;
    maxi = n / 4;
    mini = n / 6;
    bool difficulty1 = false, difficulty2 = false;
    if (n % 4 != 2 && n % 4 != 0) {
 
        // This indicates series can't be represented
        // with the means of 4
        difficulty1 = true;
    }
    if (n % 6 == 2) {
 
        // One 6 combine with this 2
        // lets say series is 6+6+6+2
        // it becomes 6+6+8
        // further 6+6+4+4
        mini++;
    }
    else if (n % 6 == 4) {
 
        // Say series is 6+6+6+4
        // count this 4 also
        mini++;
    }
    else if (n % 6 != 0) {
 
        // This indicates series can't be represented
        // with the means of 6
        difficulty2 = true;
    }
 
    if (difficulty1 and difficulty2) {
        return { -1, -1 };
    }
    return { mini, maxi };
}
 
// Driver Code
int main()
{
    int N = 10;
 
    // Function Call
    pair<int, int> ans
        = checkdivisibilityby4and6(N);
    if (ans.first == -1 and ans.second == -1)
        cout << "NOT POSSIBLE";
    else
        cout << "Minimum Terms = " << ans.first
             << "\nMaximum Terms = " << ans.second;
    return 0;
}

// Java code to implement the approach
import java.io.*;
 
class GFG {
    // Function to find the minimum
    // and the maximum terms
    public static int[] checkdivisibilityby4and6(int n)
    {
        // Edge case
        if (n < 4) {
            int ans[] = { -1, -1 };
            return ans;
        }
        int maxi = n / 4;
        int mini = n / 6;
        boolean difficulty1 = false, difficulty2 = false;
        if (n % 4 != 2 && n % 4 != 0) {
 
            // This indicates series can't be represented
            // with the means of 4
            difficulty1 = true;
        }
        if (n % 6 == 2) {
 
            // One 6 combine with this 2
            // lets say series is 6+6+6+2
            // it becomes 6+6+8
            // further 6+6+4+4
            mini++;
        }
        else if (n % 6 == 4) {
 
            // Say series is 6+6+6+4
            // count this 4 also
            mini++;
        }
        else if (n % 6 != 0) {
 
            // This indicates series can't be represented
            // with the means of 6
            difficulty2 = true;
        }
 
        if (difficulty1 == true && difficulty2 == true) {
            int ans[] = { -1, -1 };
            return ans;
        }
        int ans[] = { mini, maxi };
        return ans;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 10;
 
        // Function Call
        int ans[] = checkdivisibilityby4and6(N);
        if (ans[0] == -1 && ans[1] == -1)
            System.out.print("NOT POSSIBLE");
        else
            System.out.print("Minimum Terms = " + ans[0]
                             + "\nMaximum Terms = "
                             + ans[1]);
    }
}
 
// This code is contributed by Rohit Pradhan

# Python3 code to implement the approach
 
# Function to find the minimum
# and the maximum terms
def checkdivisibilityby4and6(n) :
 
    # Edge case
    if (n < 4) :
        return (-1, -1 );
         
    maxi = n // 4;
    mini = n // 6;
     
    difficulty1 = False;
    difficulty2 = False;
     
    if (n % 4 != 2 and n % 4 != 0) :
 
        # This indicates series can't be represented
        # with the means of 4
        difficulty1 = True;
 
    if (n % 6 == 2) :
 
        # One 6 combine with this 2
        # lets say series is 6+6+6+2
        # it becomes 6+6+8
        # further 6+6+4+4
        mini += 1;
 
    elif (n % 6 == 4) :
 
        # Say series is 6+6+6+4
        # count this 4 also
        mini += 1;
         
    elif (n % 6 != 0) :
 
        # This indicates series can't be represented
        # with the means of 6
        difficulty2 = True;
 
    if (difficulty1 and difficulty2) :
        return ( -1, -1 );
 
    return ( mini, maxi );
 
# Driver Code
if __name__ == "__main__" :
 
    N = 10;
 
    # Function Call
    ans = checkdivisibilityby4and6(N);
     
    if (ans[0] == -1 and ans[1] == -1) :
        print("NOT POSSIBLE");
    else :
        print("Minimum Terms = ",ans[0],"\nMaximum Terms = ",ans[1]);
 
    # This code is contributed by AnkThon

// C# code to implement the approach
using System;
 
class GFG {
    // Function to find the minimum
    // and the maximum terms
    public static int[] checkdivisibilityby4and6(int n)
    {
        // Edge case
        if (n < 4) {
            int []ans_1 = { -1, -1 };
            return ans_1;
        }
        int maxi = n / 4;
        int mini = n / 6;
        bool difficulty1 = false, difficulty2 = false;
        if (n % 4 != 2 && n % 4 != 0) {
 
            // This indicates series can't be represented
            // with the means of 4
            difficulty1 = true;
        }
        if (n % 6 == 2) {
 
            // One 6 combine with this 2
            // lets say series is 6+6+6+2
            // it becomes 6+6+8
            // further 6+6+4+4
            mini++;
        }
        else if (n % 6 == 4) {
 
            // Say series is 6+6+6+4
            // count this 4 also
            mini++;
        }
        else if (n % 6 != 0) {
 
            // This indicates series can't be represented
            // with the means of 6
            difficulty2 = true;
        }
 
        if (difficulty1 == true && difficulty2 == true) {
            int []ans_2 = { -1, -1 };
            return ans_2;
        }
        int []ans_3 = { mini, maxi };
        return ans_3;
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int N = 10;
 
        // Function Call
        int []ans = checkdivisibilityby4and6(N);
        if (ans[0] == -1 && ans[1] == -1)
            Console.WriteLine("NOT POSSIBLE");
        else
            Console.WriteLine("Minimum Terms = " + ans[0]
                             + "\nMaximum Terms = "
                             + ans[1]);
    }
}
 
// This code is contributed by AnkThon

Minimum Terms = 2
Maximum Terms = 2

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