Open In App

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

## Javascript

 ``

Output:

`6, 10, 14, 15, 7`

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