# Split n into maximum composite numbers

Given n, print the maximum number of composite numbers that sum up to n. First few composite numbers are 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, â€¦â€¦â€¦ **Examples:**

Input: 90 Output: 22 Explanation: If we add 21 4's, then we get 84 and then add 6 to it, we get 90. Input: 10 Output: 2 Explanation: 4 + 6 = 10

Below are some important observations.

- If the number is less than 4, it wonâ€™t have any combinations.
- If the number is 5, 7, 11, it wont have any splitting.
- Since smallest composite number is 4, it makes sense to use maximum number of 4s.
- For numbers that don’t leave a composite remainder when divided by 4, we do following. If remainder is 1, we subtract 9 from it to get the number which is perfectly divisible by 4. If the remainder is 2, then subtract 6 from it to make n a number which is perfectly divisible by 4. If the remainder is 3, then subtract 15 from it to make n perfectly divisible by 4, and 15 can be made up by 9 + 6.

So the main observation is to make n such that is composes of maximum no of 4â€™s and the remaining can be made up by 6 and 9. We wonâ€™t need composite numbers more than that, as the composite numbers above 9 can be made up of 4, 6, and 9.

Below is the implementation of the above approach

## C++

`// CPP program to split a number into maximum` `// number of composite numbers.` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// function to calculate the maximum number of` `// composite numbers adding upto n` `int` `count(` `int` `n)` `{` ` ` `// 4 is the smallest composite number` ` ` `if` `(n < 4)` ` ` `return` `-1;` ` ` `// stores the remainder when n is divided` ` ` `// by 4` ` ` `int` `rem = n % 4;` ` ` `// if remainder is 0, then it is perfectly ` ` ` `// divisible by 4.` ` ` `if` `(rem == 0)` ` ` `return` `n / 4;` ` ` `// if the remainder is 1` ` ` `if` `(rem == 1) {` ` ` `// If the number is less than 9, that` ` ` `// is 5, then it cannot be expressed as ` ` ` `// 4 is the only composite number less ` ` ` `// than 5` ` ` `if` `(n < 9)` ` ` `return` `-1;` ` ` `// If the number is greater than 8, and ` ` ` `// has a remainder of 1, then express n` ` ` `// as n-9 a and it is perfectly divisible ` ` ` `// by 4 and for 9, count 1.` ` ` `return` `(n - 9) / 4 + 1;` ` ` `}` ` ` ` ` `// When remainder is 2, just subtract 6 from n, ` ` ` `// so that n is perfectly divisible by 4 and` ` ` `// count 1 for 6 which is subtracted.` ` ` `if` `(rem == 2)` ` ` `return` `(n - 6) / 4 + 1;` ` ` `// if the number is 7, 11 which cannot be ` ` ` `// expressed as sum of any composite numbers` ` ` `if` `(rem == 3) {` ` ` `if` `(n < 15)` ` ` `return` `-1;` ` ` `// when the remainder is 3, then subtract` ` ` `// 15 from it and n becomes perfectly ` ` ` `// divisible by 4 and we add 2 for 9 and 6,` ` ` `// which is getting subtracted to make n ` ` ` `// perfectly divisible by 4.` ` ` `return` `(n - 15) / 4 + 2;` ` ` `}` `}` `// driver program to test the above function` `int` `main()` `{` ` ` `int` `n = 90;` ` ` `cout << count(n) << endl;` ` ` `n = 143;` ` ` `cout << count(n) << endl;` ` ` `return` `0; ` `}` |

## Java

`// Java program to split a number into maximum` `// number of composite numbers.` `import` `java.io.*;` `class` `GFG ` `{` ` ` `// function to calculate the maximum number of` ` ` `// composite numbers adding upto n` ` ` `static` `int` `count(` `int` `n)` ` ` `{` ` ` `// 4 is the smallest composite number` ` ` `if` `(n < ` `4` `)` ` ` `return` `-` `1` `;` ` ` ` ` `// stores the remainder when n is divided` ` ` `// by 4` ` ` `int` `rem = n % ` `4` `;` ` ` ` ` `// if remainder is 0, then it is perfectly ` ` ` `// divisible by 4.` ` ` `if` `(rem == ` `0` `)` ` ` `return` `n / ` `4` `;` ` ` ` ` `// if the remainder is 1` ` ` `if` `(rem == ` `1` `) {` ` ` ` ` `// If the number is less than 9, that` ` ` `// is 5, then it cannot be expressed as ` ` ` `// 4 is the only composite number less ` ` ` `// than 5` ` ` `if` `(n < ` `9` `)` ` ` `return` `-` `1` `;` ` ` ` ` `// If the number is greater than 8, and ` ` ` `// has a remainder of 1, then express n` ` ` `// as n-9 a and it is perfectly divisible ` ` ` `// by 4 and for 9, count 1.` ` ` `return` `(n - ` `9` `) / ` `4` `+ ` `1` `;` ` ` `}` ` ` ` ` ` ` `// When remainder is 2, just subtract 6 from n, ` ` ` `// so that n is perfectly divisible by 4 and` ` ` `// count 1 for 6 which is subtracted.` ` ` `if` `(rem == ` `2` `)` ` ` `return` `(n - ` `6` `) / ` `4` `+ ` `1` `;` ` ` ` ` ` ` `// if the number is 7, 11 which cannot be ` ` ` `// expressed as sum of any composite numbers` ` ` `if` `(rem == ` `3` `) ` ` ` `{` ` ` `if` `(n < ` `15` `)` ` ` `return` `-` `1` `;` ` ` ` ` `// when the remainder is 3, then subtract` ` ` `// 15 from it and n becomes perfectly ` ` ` `// divisible by 4 and we add 2 for 9 and 6,` ` ` `// which is getting subtracted to make n ` ` ` `// perfectly divisible by 4.` ` ` `return` `(n - ` `15` `) / ` `4` `+ ` `2` `;` ` ` `}` ` ` `return` `0` `;` ` ` `}` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `main (String[] args) ` ` ` `{` ` ` `int` `n = ` `90` `;` ` ` `System.out.println(count(n));` ` ` `n = ` `143` `;` ` ` `System.out.println(count(n));` ` ` `}` `} ` `// This code is contributed by vt_m.` |

## Python3

`# Python3 program to split a number into ` `# maximum number of composite numbers.` `# Function to calculate the maximum number ` `# of composite numbers adding upto n` `def` `count(n):` ` ` `# 4 is the smallest composite number` ` ` `if` `(n < ` `4` `):` ` ` `return` `-` `1` ` ` `# stores the remainder when n ` ` ` `# is divided n is divided by 4` ` ` `rem ` `=` `n ` `%` `4` ` ` `# if remainder is 0, then it is ` ` ` `# perfectly divisible by 4.` ` ` `if` `(rem ` `=` `=` `0` `):` ` ` `return` `n ` `/` `/` `4` ` ` `# if the remainder is 1` ` ` `if` `(rem ` `=` `=` `1` `):` ` ` `# If the number is less than 9, that` ` ` `# is 5, then it cannot be expressed as ` ` ` `# 4 is the only composite number less ` ` ` `# than 5` ` ` `if` `(n < ` `9` `):` ` ` `return` `-` `1` ` ` `# If the number is greater than 8, and ` ` ` `# has a remainder of 1, then express n` ` ` `# as n-9 a and it is perfectly divisible ` ` ` `# by 4 and for 9, count 1.` ` ` `return` `(n ` `-` `9` `) ` `/` `/` `4` `+` `1` ` ` ` ` ` ` `# When remainder is 2, just subtract 6 from n, ` ` ` `# so that n is perfectly divisible by 4 and` ` ` `# count 1 for 6 which is subtracted.` ` ` `if` `(rem ` `=` `=` `2` `):` ` ` `return` `(n ` `-` `6` `) ` `/` `/` `4` `+` `1` ` ` `# if the number is 7, 11 which cannot be ` ` ` `# expressed as sum of any composite numbers` ` ` `if` `(rem ` `=` `=` `3` `): ` ` ` `if` `(n < ` `15` `):` ` ` `return` `-` `1` ` ` `# when the remainder is 3, then subtract` ` ` `# 15 from it and n becomes perfectly ` ` ` `# divisible by 4 and we add 2 for 9 and 6,` ` ` `# which is getting subtracted to make n ` ` ` `# perfectly divisible by 4.` ` ` `return` `(n ` `-` `15` `) ` `/` `/` `4` `+` `2` `# Driver Code` `n ` `=` `90` `print` `(count(n))` `n ` `=` `143` `print` `(count(n))` `# This code is contributed by Anant Agarwal.` |

## C#

`// C# program to split a number into maximum` `// number of composite numbers.` `using` `System;` `class` `GFG {` ` ` ` ` `// function to calculate the maximum number` ` ` `// of composite numbers adding upto n` ` ` `static` `int` `count(` `int` `n)` ` ` `{` ` ` ` ` `// 4 is the smallest composite number` ` ` `if` `(n < 4)` ` ` `return` `-1;` ` ` ` ` `// stores the remainder when n is divided` ` ` `// by 4` ` ` `int` `rem = n % 4;` ` ` ` ` `// if remainder is 0, then it is perfectly ` ` ` `// divisible by 4.` ` ` `if` `(rem == 0)` ` ` `return` `n / 4;` ` ` ` ` `// if the remainder is 1` ` ` `if` `(rem == 1) {` ` ` ` ` `// If the number is less than 9, that` ` ` `// is 5, then it cannot be expressed as ` ` ` `// 4 is the only composite number less ` ` ` `// than 5` ` ` `if` `(n < 9)` ` ` `return` `-1;` ` ` ` ` `// If the number is greater than 8, and ` ` ` `// has a remainder of 1, then express n` ` ` `// as n-9 a and it is perfectly divisible ` ` ` `// by 4 and for 9, count 1.` ` ` `return` `(n - 9) / 4 + 1;` ` ` `}` ` ` ` ` ` ` `// When remainder is 2, just subtract 6 from n, ` ` ` `// so that n is perfectly divisible by 4 and` ` ` `// count 1 for 6 which is subtracted.` ` ` `if` `(rem == 2)` ` ` `return` `(n - 6) / 4 + 1;` ` ` ` ` ` ` `// if the number is 7, 11 which cannot be ` ` ` `// expressed as sum of any composite numbers` ` ` `if` `(rem == 3) ` ` ` `{` ` ` `if` `(n < 15)` ` ` `return` `-1;` ` ` ` ` `// when the remainder is 3, then subtract` ` ` `// 15 from it and n becomes perfectly ` ` ` `// divisible by 4 and we add 2 for 9 and 6,` ` ` `// which is getting subtracted to make n ` ` ` `// perfectly divisible by 4.` ` ` `return` `(n - 15) / 4 + 2;` ` ` `}` ` ` ` ` `return` `0;` ` ` `}` ` ` ` ` `// Driver program ` ` ` `public` `static` `void` `Main() ` ` ` `{` ` ` `int` `n = 90;` ` ` `Console.WriteLine(count(n));` ` ` ` ` `n = 143;` ` ` `Console.WriteLine(count(n));` ` ` `}` `} ` ` ` `// This code is contributed by Anant Agarwal.` |

## PHP

`<?php` `// PHP program to split a number` `// into maximum number of ` `// composite numbers.` `// function to calculate the` `// maximum number of composite ` `// numbers adding upto n` `function` `c_ount(` `$n` `)` `{` ` ` ` ` `// 4 is the smallest` ` ` `// composite number` ` ` `if` `(` `$n` `< 4)` ` ` `return` `-1;` ` ` `// stores the remainder when` ` ` `// n is divided by 4` ` ` `$rem` `= ` `$n` `% 4;` ` ` `// if remainder is 0, then it ` ` ` `// is perfectly divisible by 4.` ` ` `if` `(` `$rem` `== 0)` ` ` `return` `$n` `/ 4;` ` ` `// if the remainder is 1` ` ` `if` `(` `$rem` `== 1) {` ` ` `// If the number is less ` ` ` `// then 9, that is 5, then` ` ` `// it cannot be expressed` ` ` `// as 4 is the only ` ` ` `//composite number less ` ` ` `// than 5` ` ` `if` `(` `$n` `< 9)` ` ` `return` `-1;` ` ` `// If the number is greater ` ` ` `// then 8, and has a ` ` ` `// remainder of 1, then ` ` ` `// express n as n-9 a and` ` ` `// it is perfectly divisible ` ` ` `// by 4 and for 9, count 1.` ` ` `return` `(` `$n` `- 9) / 4 + 1;` ` ` `}` ` ` ` ` `// When remainder is 2, just ` ` ` `// subtract 6 from n, so that n` ` ` `// is perfectly divisible by 4` ` ` `// and count 1 for 6 which is` ` ` `// subtracted.` ` ` `if` `(` `$rem` `== 2)` ` ` `return` `(` `$n` `- 6) / 4 + 1;` ` ` `// if the number is 7, 11 which` ` ` `// cannot be expressed as sum of` ` ` `// any composite numbers` ` ` `if` `(` `$rem` `== 3) {` ` ` `if` `(` `$n` `< 15)` ` ` `return` `-1;` ` ` `// when the remainder is 3, ` ` ` `// then subtract 15 from it ` ` ` `// and n becomes perfectly` ` ` `// divisible by 4 and we add` ` ` `// 2 for 9 and 6, which is ` ` ` `// getting subtracted to make` ` ` `// n perfectly divisible by 4.` ` ` `return` `(` `$n` `- 15) / 4 + 2;` ` ` `}` `}` `// driver program to test the above` `// function` ` ` `$n` `= 90;` ` ` `echo` `c_ount(` `$n` `),` `"\n"` `;` ` ` `$n` `= 143;` ` ` `echo` `c_ount(` `$n` `);` `// This code is contributed by anuj_67.` `?>` |

## Javascript

`<script>` ` ` `// Javascript program to split a number` `// into maximum number of ` `// composite numbers.` ` ` `// function to calculate the` `// maximum number of composite ` `// numbers adding upto n` `function` `c_ount(n)` `{` ` ` ` ` `// 4 is the smallest` ` ` `// composite number` ` ` `if` `(n < 4)` ` ` `return` `-1;` ` ` ` ` `// stores the remainder when` ` ` `// n is divided by 4` ` ` `let rem = n % 4;` ` ` ` ` `// if remainder is 0, then it ` ` ` `// is perfectly divisible by 4.` ` ` `if` `(rem == 0)` ` ` `return` `n / 4;` ` ` ` ` `// if the remainder is 1` ` ` `if` `(rem == 1) {` ` ` ` ` `// If the number is less ` ` ` `// then 9, that is 5, then` ` ` `// it cannot be expressed` ` ` `// as 4 is the only ` ` ` `//composite number less ` ` ` `// than 5` ` ` `if` `(n < 9)` ` ` `return` `-1;` ` ` ` ` `// If the number is greater ` ` ` `// then 8, and has a ` ` ` `// remainder of 1, then ` ` ` `// express n as n-9 a and` ` ` `// it is perfectly divisible ` ` ` `// by 4 and for 9, count 1.` ` ` `return` `(n - 9) / 4 + 1;` ` ` `}` ` ` ` ` ` ` `// When remainder is 2, just ` ` ` `// subtract 6 from n, so that n` ` ` `// is perfectly divisible by 4` ` ` `// and count 1 for 6 which is` ` ` `// subtracted.` ` ` `if` `(rem == 2)` ` ` `return` `(n - 6) / 4 + 1;` ` ` ` ` ` ` `// if the number is 7, 11 which` ` ` `// cannot be expressed as sum of` ` ` `// any composite numbers` ` ` `if` `(rem == 3) {` ` ` `if` `(n < 15)` ` ` `return` `-1;` ` ` ` ` `// when the remainder is 3, ` ` ` `// then subtract 15 from it ` ` ` `// and n becomes perfectly` ` ` `// divisible by 4 and we add` ` ` `// 2 for 9 and 6, which is ` ` ` `// getting subtracted to make` ` ` `// n perfectly divisible by 4.` ` ` `return` `(n - 15) / 4 + 2;` ` ` `}` `}` ` ` `// driver program to test the above` `// function` ` ` ` ` `let n = 90;` ` ` `document.write(c_ount(n) + ` `"<br>"` `);` ` ` ` ` `n = 143;` ` ` `document.write(c_ount(n));` ` ` `// This code is contributed by _saurabh_jaiswal.` `</script>` |

Output:

22 34

Time complexity: O(1)

Auxiliary Space: O(1)

This article is contributed by **Raja Vikramaditya**. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

## Please

Loginto comment...