Related Articles
Split N as the sum of K numbers satisfying the given conditions
• Last Updated : 26 Aug, 2020

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[10005];`` ` `    ``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``[10005];``    ``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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up