Open in App
Not now

# Find minimum and maximum number of terms to divide N as sum of 4 or 6

• Last Updated : 02 Aug, 2022

Given an integer N, the task is to find the minimum and the maximum number of terms required to divide N as the sum of 4 or 6.

Examples:

Input: N = 3
Output: NOT POSSIBLE
Explanation: As the number is less than 4, it is not possible.

Input: N = 10
Output : Minimum Terms = 2, Maximum Terms =  2
Explanation: There is only one possible division (4 + 6).

Approach: The problem can be solved based on the following mathematical observation:

If N can be expressed in terms of 4 and 6 then the answer must lie near N/6 for minimum terms and near N/4 for maximum terms.
If N%6 leaves a remainder 2 it can be replaced by two 4’s and If N%6 leaves a remainder 4, one 4 can be added.
If N%4 leaves a remainder 2 then it can be replaced by one 6.

Follow the steps mentioned below to implement the idea:

• Initialize two variables (say maxi and mini) with N/4 and N/6 respectively to store the maximum and the minimum number of terms.
• N%4 could be 0, 1, 2 or 3.
• If it is either 1 or 3 we can’t represent this series with the means of 4.
• If N%4 is 2 then the last term of the series i.e., 4 will combine with this 2 to make 6. Hence we can represent the series with the use of either 4 or 6.
• Similarly, N%6 can be 0, 1, 2, 3, 4, 5.
• If it is 1, 3, or 5  we can’t represent this series with the means of 6.
• If N%6 is 2 then the last term of the series i.e., 6 will combine with this 2 to make 8, which further can break into two pieces of 4.
• If N%6 is 4 then just increase the mini by one as 4 can be used to represent the series.
• Return the minimum and maximum calculated in this way.

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach`   `#include ` `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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output

```Minimum Terms = 2
Maximum Terms = 2```

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

My Personal Notes arrow_drop_up
Related Articles