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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to implement
// the above approach
import java.util.*;
class GFG{
  
// Vector to store prime numbers
static Vector<Integer> 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<Integer> 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


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.