# Split N as the sum of K numbers satisfying the given conditions

Given an integer N, the task is to express the given number as the sum of K numbers where at least K – 1 numbers are distinct and are product of 2 primes. If no possible answer, exists, print -1.

Examples:

Input: N = 52, K = 5
Output: 6 10 14 15 7
Explanation:
N = 52 can be expressed as 6 10 14 15 2, where 15 = 3 * 5, 14 = 2*7, 10 = 2*5, 6 = 2*3, i.e, atleast 4 numbers are product of 2 distinct prime numbers.

Input: N = 44 K = 5
Output: -1
Explanation: It is not possible to express N as product of distinct numbers.

Approach: Follow the steps below to solve the problem:

• Store all prime numbers in a vector using Sieve of Eratosthenes.
• Iterate through the prime numbers stored and store the product of every pair of a prime number in another vector prod.
• Print the first K – 1 elements of prod vector
• If the sum of the first K – 1 elements of prod vector is more than N then print -1.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Vector to store prime numbers ` `vector<``int``> primes; ` ` `  `// Function to generate prime ` `// numbers using SieveOfEratosthenes ` `void` `SieveOfEratosthenes() ` `{ ` `    ``// Boolean array to store primes ` `    ``bool` `prime; ` ` `  `    ``memset``(prime, ``true``, ``sizeof``(prime)); ` ` `  `    ``for` `(``int` `p = 2; p * p <= 1000; p++) { ` ` `  `        ``// If p is a prime ` `        ``if` `(prime[p] == ``true``) { ` ` `  `            ``// Mark all its multiples as non-prime ` `            ``for` `(``int` `i = p * p; i <= 1000; i += p) ` `                ``prime[i] = ``false``; ` `        ``} ` `    ``} ` ` `  `    ``// Print all prime numbers ` `    ``for` `(``int` `p = 2; p <= 1000; p++) ` `        ``if` `(prime[p]) ` `            ``primes.push_back(p); ` `} ` ` `  `// Function to generate n as the sum ` `// of k numbers where atleast K - 1 ` `// are distinct and are product of 2 primes ` `void` `generate(``int` `n, ``int` `k) ` `{ ` `    ``// Stores the product of every ` `    ``// pair of prime number ` `    ``vector<``long` `long``> prod; ` ` `  `    ``SieveOfEratosthenes(); ` ` `  `    ``int` `l = primes.size(); ` ` `  `    ``for` `(``int` `i = 0; i < l; i++) { ` `        ``for` `(``int` `j = i + 1; j < l; j++) { ` `            ``if` `(primes[i] * primes[j] > 0) ` `                ``prod.push_back(primes[i] ` `                               ``* primes[j]); ` `        ``} ` `    ``} ` ` `  `    ``// Sort the products ` `    ``sort(prod.begin(), prod.end()); ` ` `  `    ``int` `sum = 0; ` `    ``for` `(``int` `i = 0; i < k - 1; i++) ` `        ``sum += prod[i]; ` ` `  `    ``// If sum exceeds n ` `    ``if` `(sum > n) ` `        ``cout << ``"-1"``; ` ` `  `    ``// Otherwise, print the k ` `    ``// required numbers ` `    ``else` `{ ` `        ``for` `(``int` `i = 0; i < k - 1; i++) { ` `            ``cout << prod[i] << ``", "``; ` `        ``} ` `        ``cout << n - sum << ``"\n"``; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 52, k = 5; ` `    ``generate(n, k); ` `    ``return` `0; ` `} `

## Java

 `// Java Program to implement ` `// the above approach ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `// Vector to store prime numbers ` `static` `Vector primes = ``new` `Vector<>(); ` ` `  `// Function to generate prime ` `// numbers using SieveOfEratosthenes ` `static` `void` `SieveOfEratosthenes() ` `{ ` `    ``// Boolean array to store primes ` `    ``boolean` `[]prime = ``new` `boolean``[``10005``]; ` `    ``Arrays.fill(prime, ``true``); ` ` `  `    ``for` `(``int` `p = ``2``; p * p <= ``1000``; p++) ` `    ``{ ` ` `  `        ``// If p is a prime ` `        ``if` `(prime[p] == ``true``)  ` `        ``{ ` ` `  `            ``// Mark all its multiples as non-prime ` `            ``for` `(``int` `i = p * p; i <= ``1000``; i += p) ` `                ``prime[i] = ``false``; ` `        ``} ` `    ``} ` ` `  `    ``// Print all prime numbers ` `    ``for` `(``int` `p = ``2``; p <= ``1000``; p++) ` `        ``if` `(prime[p]) ` `            ``primes.add(p); ` `} ` ` `  `// Function to generate n as the sum ` `// of k numbers where atleast K - 1 ` `// are distinct and are product of 2 primes ` `static` `void` `generate(``int` `n, ``int` `k) ` `{ ` `    ``// Stores the product of every ` `    ``// pair of prime number ` `    ``Vector prod = ``new` `Vector<>(); ` `    ``SieveOfEratosthenes(); ` ` `  `    ``int` `l = primes.size(); ` ` `  `    ``for` `(``int` `i = ``0``; i < l; i++)  ` `    ``{ ` `        ``for` `(``int` `j = i + ``1``; j < l; j++)  ` `        ``{ ` `            ``if` `(primes.get(i) * primes.get(j) > ``0``) ` `                ``prod.add(primes.get(i) *  ` `                         ``primes.get(j)); ` `        ``} ` `    ``} ` ` `  `    ``// Sort the products ` `    ``Collections.sort(prod); ` ` `  `    ``int` `sum = ``0``; ` `    ``for` `(``int` `i = ``0``; i < k - ``1``; i++) ` `        ``sum += prod.get(i); ` ` `  `    ``// If sum exceeds n ` `    ``if` `(sum > n) ` `        ``System.out.print(``"-1"``); ` ` `  `    ``// Otherwise, print the k ` `    ``// required numbers ` `    ``else` `    ``{ ` `        ``for` `(``int` `i = ``0``; i < k - ``1``; i++)  ` `        ``{ ` `            ``System.out.print(prod.get(i) + ``", "``); ` `        ``} ` `        ``System.out.print(n - sum + ``"\n"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``52``, k = ``5``; ` `    ``generate(n, k); ` `} ` `} ` ` `  `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program to implement ` `# the above approach ` ` `  `# list to store prime numbers ` `primes ``=` `[] ` ` `  `# Function to generate prime ` `# numbers using SieveOfEratosthenes ` `def` `SieveOfEratosthenes(): ` ` `  `    ``# Boolean array to store primes ` `    ``prime ``=` `[``True``] ``*` `10005` ` `  `    ``p ``=` `2` `    ``while` `p ``*` `p <``=` `1000``: ` ` `  `        ``# If p is a prime ` `        ``if` `(prime[p] ``=``=` `True``): ` ` `  `            ``# Mark all its multiples as non-prime ` `            ``for` `i ``in` `range``(p ``*` `p, ``1001``, p): ` `                ``prime[i] ``=` `False` `         `  `        ``p ``+``=` `1` ` `  `    ``# Print all prime numbers ` `    ``for` `p ``in` `range``(``2``, ``1001``): ` `        ``if` `(prime[p]): ` `            ``primes.append(p) ` ` `  `# Function to generate n as the sum ` `# of k numbers where atleast K - 1 ` `# are distinct and are product of 2 primes ` `def` `generate(n, k): ` ` `  `    ``# Stores the product of every ` `    ``# pair of prime number ` `    ``prod ``=` `[] ` ` `  `    ``SieveOfEratosthenes() ` ` `  `    ``l ``=` `len``(primes) ` ` `  `    ``for` `i ``in` `range``(l): ` `        ``for` `j ``in` `range``(i ``+` `1``, l): ` `            ``if` `(primes[i] ``*` `primes[j] > ``0``): ` `                ``prod.append(primes[i] ``*`  `                            ``primes[j]) ` ` `  `    ``# Sort the products ` `    ``prod.sort() ` ` `  `    ``sum` `=` `0` `    ``for` `i ``in` `range``(k ``-` `1``): ` `        ``sum` `+``=` `prod[i] ` ` `  `    ``# If sum exceeds n ` `    ``if` `(``sum` `> n): ` `        ``print` `(``"-1"``) ` ` `  `    ``# Otherwise, print the k ` `    ``# required numbers ` `    ``else``: ` `        ``for` `i ``in` `range``(k ``-` `1``): ` `            ``print``(prod[i], end ``=` `", "``) ` `             `  `        ``print``(n ``-` `sum``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``n ``=` `52` `    ``k ``=` `5` `     `  `    ``generate(n, k) ` ` `  `# This code is contributed by chitranayal `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `// List to store prime numbers ` `static` `List<``int``> primes = ``new` `List<``int``>(); ` ` `  `// Function to generate prime ` `// numbers using SieveOfEratosthenes ` `static` `void` `SieveOfEratosthenes() ` `{ ` `     `  `    ``// Boolean array to store primes ` `    ``bool` `[]prime = ``new` `bool``; ` `    ``for``(``int` `i = 0; i < 10005; i++) ` `        ``prime[i] = ``true``; ` ` `  `    ``for``(``int` `p = 2; p * p <= 1000; p++) ` `    ``{ ` ` `  `        ``// If p is a prime ` `        ``if` `(prime[p] == ``true``)  ` `        ``{ ` ` `  `            ``// Mark all its multiples as non-prime ` `            ``for``(``int` `i = p * p; i <= 1000; i += p) ` `                ``prime[i] = ``false``; ` `        ``} ` `    ``} ` ` `  `    ``// Print all prime numbers ` `    ``for``(``int` `p = 2; p <= 1000; p++) ` `        ``if` `(prime[p]) ` `            ``primes.Add(p); ` `} ` ` `  `// Function to generate n as the sum ` `// of k numbers where atleast K - 1 ` `// are distinct and are product of 2 primes ` `static` `void` `generate(``int` `n, ``int` `k) ` `{ ` `     `  `    ``// Stores the product of every ` `    ``// pair of prime number ` `    ``List<``int``> prod = ``new` `List<``int``>(); ` `    ``SieveOfEratosthenes(); ` ` `  `    ``int` `l = primes.Count; ` ` `  `    ``for``(``int` `i = 0; i < l; i++)  ` `    ``{ ` `        ``for``(``int` `j = i + 1; j < l; j++)  ` `        ``{ ` `            ``if` `(primes[i] * primes[j] > 0) ` `                ``prod.Add(primes[i] *  ` `                         ``primes[j]); ` `        ``} ` `    ``} ` ` `  `    ``// Sort the products ` `    ``prod.Sort(); ` ` `  `    ``int` `sum = 0; ` `    ``for``(``int` `i = 0; i < k - 1; i++) ` `        ``sum += prod[i]; ` ` `  `    ``// If sum exceeds n ` `    ``if` `(sum > n) ` `        ``Console.Write(``"-1"``); ` ` `  `    ``// Otherwise, print the k ` `    ``// required numbers ` `    ``else` `    ``{ ` `        ``for` `(``int` `i = 0; i < k - 1; i++)  ` `        ``{ ` `            ``Console.Write(prod[i] + ``", "``); ` `        ``} ` `        ``Console.Write(n - sum + ``"\n"``); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 52, k = 5; ` `     `  `    ``generate(n, k); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar  `

Output:

```6, 10, 14, 15, 7
```

Time complexity: O(N log N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.