Skip to content
Related Articles

Related Articles

Sum and product of k smallest and k largest prime numbers in the array
  • Difficulty Level : Easy
  • Last Updated : 12 Jun, 2019

Given an integer k and an array of integers arr, the task is to find the sum and product of k smallest and k largest prime numbers in the array.
Assume that there are at least k prime numbers in the array.

Examples:

Input: arr[] = {2, 5, 6, 8, 10, 11}, k = 2
Output: Sum of k-minimum prime numbers is 7
Sum of k-maximum prime numbers is 16
Product of k-minimum prime numbers is 10
Product of k-maximum prime numbers is 55
{2, 5, 11} are the only prime numbers from the array. {2, 5} are the 2 smallest and {5, 11} are the 2 largest among them.

Input: arr[] = {4, 2, 12, 13, 5, 19}, k = 3
Output: Sum of k-minimum prime numbers is 20
Sum of k-maximum prime numbers is 37
Product of k-minimum prime numbers is 130
Product of k-maximum prime numbers is 1235

Approach:



  1. Using Sieve of Eratosthenes generate a boolean vector upto the size of the maximum element from the array which can be used to check whether a number is prime or not.
  2. Also set 0 and 1 as non-prime so that they don’t get counted as prime numbers.
  3. Now traverse the array and insert all the numbers which are prime in two heaps, a min heap and a max heap.
  4. Now, pop out top k elements from the min heap and take the sum and product of the minimum k prime numbers.
  5. Do the same with the max heap to get the sum and product of the max k prime numbers.
  6. Finally, print the results.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the sum
// and product of k smallest and
// k largest prime numbers in an array
#include <bits/stdc++.h>
using namespace std;
  
vector<bool> SieveOfEratosthenes(int max_val)
{
    // Create a boolean vector "prime[0..n]". A
    // value in prime[i] will finally be false
    // if i is Not a prime, else true.
    vector<bool> prime(max_val + 1, true);
    for (int p = 2; p * p <= max_val; p++) {
  
        // If prime[p] is not changed, then
        // it is a prime
        if (prime[p] == true) {
  
            // Update all multiples of p
            for (int i = p * 2; i <= max_val; i += p)
                prime[i] = false;
        }
    }
    return prime;
}
  
// Function that calculates the sum
// and product of k smallest and k
// largest prime numbers in an array
void primeSumAndProduct(int arr[], int n, int k)
{
    // Find maximum value in the array
    int max_val = *max_element(arr, arr + n);
  
    // Use sieve to find all prime numbers
    // less than or equal to max_val
    vector<bool> prime = SieveOfEratosthenes(max_val);
  
    // Set 0 and 1 as non-primes as
    // they don't need to be
    // counted as prime numbers
    prime[0] = false;
    prime[1] = false;
  
    // Max Heap to store all the prime numbers
    priority_queue<int> maxHeap;
  
    // Min Heap to store all the prime numbers
    priority_queue<int, vector<int>, greater<int>> 
        minHeap;
  
    // Push all the prime numbers 
    // from the array to the heaps
    for (int i = 0; i < n; i++)
        if (prime[arr[i]]) {
            minHeap.push(arr[i]);
            maxHeap.push(arr[i]);
        }
    long long int minProduct = 1
        , maxProduct = 1
        , minSum = 0
        , maxSum = 0;
    while (k--) {
  
        // Calculate the products
        minProduct *= minHeap.top();
        maxProduct *= maxHeap.top();
  
        // Calculate the sum
        minSum += minHeap.top();
        maxSum += maxHeap.top();
  
        // Pop the current minimum element
        minHeap.pop();
  
        // Pop the current maximum element
        maxHeap.pop();
    }
  
    cout << "Sum of k-minimum prime numbers is " 
         << minSum << "\n";
    cout << "Sum of k-maximum prime numbers is " 
         << maxSum << "\n";
    cout << "Product of k-minimum prime numbers is " 
         << minProduct << "\n";
    cout << "Product of k-maximum prime numbers is " 
         << maxProduct;
}
  
// Driver code
int main()
{
  
    int arr[] = { 4, 2, 12, 13, 5, 19 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    int k = 3;
  
    primeSumAndProduct(arr, n, k);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the sum 
// and product of k smallest and 
// k largest prime numbers in an array 
import java.util.*;
  
class GFG 
{
    public static void main(String[] args) 
    {
        int arr[] = { 4, 2, 12, 13, 5, 19 };
        int n = arr.length;
        int k = 3;
        primeSumAndProduct(arr, n, k);
    }
  
    static boolean[] SieveOfEratosthenes(int max_val) 
    {
        // Create a boolean vector "prime[0..n]". A
        // value in prime[i] will finally be false
        // if i is Not a prime, else true.
        boolean[] prime = new boolean[max_val + 1];
        for(int i = 0;i <= max_val ; i++)
        prime[i] = true;
        for (int p = 2; p * p <= max_val; p++)
        {
  
            // If prime[p] is not changed, then
            // it is a prime
            if (prime[p] == true
            {
  
                // Update all multiples of p
                for (int i = p * 2; i <= max_val; i += p)
                    prime[i] = false;
            }
        }
        return prime;
    }
  
    // Function that calculates the sum
    // and product of k smallest and k
    // largest prime numbers in an array
    static void primeSumAndProduct(int arr[], int n, int k) 
    {
        // Find maximum value in the array
        int max_val = 0;
        for (int i = 0; i < n; i++)
            max_val = Math.max(max_val, arr[i]);
  
        // Use sieve to find all prime numbers
        // less than or equal to max_val
        boolean[] prime = SieveOfEratosthenes(max_val);
  
        // Set 0 and 1 as non-primes as
        // they don't need to be
        // counted as prime numbers
        prime[0] = false;
        prime[1] = false;
  
        // Max Heap to store all the prime numbers
        PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(Collections.reverseOrder());
  
        // Min Heap to store all the prime numbers
        PriorityQueue<Integer> minHeap = new PriorityQueue<Integer>();
  
        // Push all the prime numbers
        // from the array to the heaps
        for (int i = 0; i < n; i++)
            if (prime[arr[i]]) {
                minHeap.add(arr[i]);
                maxHeap.add(arr[i]);
            }
  
        long minProduct = 1, maxProduct = 1, minSum = 0, maxSum = 0;
        while (k > 0)
        {
            k--;
              
            // Calculate the products
            minProduct *= minHeap.peek();
            maxProduct *= maxHeap.peek();
  
            // Calculate the sum
            minSum += minHeap.peek();
            maxSum += maxHeap.peek();
  
            // Pop the current minimum element
            minHeap.remove();
  
            // Pop the current maximum element
            maxHeap.remove();
        }
  
        System.out.println("Sum of k-minimum prime numbers is " + minSum);
        System.out.println("Sum of k-maximum prime numbers is " + maxSum);
        System.out.println("Product of k-minimum prime numbers is " + minProduct);
        System.out.println("Product of k-maximum prime numbers is " + maxProduct);
    }
  
}
  
// This code is contributed by ankush_953

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to find the sum 
# and product of k smallest and 
# k largest prime numbers in an array 
import heapq
  
def SieveOfEratosthenes(max_val):
    # Create a boolean vector "prime[0..n]". A 
    # value in prime[i] will finally be false 
    # if i is Not a prime, else true. 
    prime = [True for i in range(max_val+1)]
    p = 2
    while p*p <= max_val:
        # If prime[p] is not changed, then 
        # it is a prime 
        if (prime[p] == True):
  
            # Update all multiples of p 
            for j in range(2*p,max_val+1,p):
                prime[j] = False
        p += 1
      
    return prime
  
# Function that calculates the sum 
# and product of k smallest and k 
# largest prime numbers in an array 
def primeSumAndProduct(arr, n, k):
    # Find maximum value in the array 
    max_val = max(arr)
  
    # Use sieve to find all prime numbers 
    # less than or equal to max_val 
    prime = SieveOfEratosthenes(max_val)
  
    # Set 0 and 1 as non-primes as 
    # they don't need to be 
    # counted as prime numbers 
    prime[0] = False
    prime[1] = False
  
    # Heap to store all the prime numbers 
    Heap = []
  
    # Push all the prime numbers 
    # from the array to the heaps 
    for i in range(n): 
        if (prime[arr[i]]):
            Heap.append(arr[i]) 
      
    minProduct = 1
    maxProduct = 1
    minSum = 0
    maxSum = 0
  
    min_k = heapq.nsmallest(k,Heap)
    max_k = heapq.nlargest(k,Heap)
  
    minSum = sum(min_k)
    maxSum = sum(max_k)
      
    for val in min_k:
        minProduct *= val
      
    for val in max_k:
        maxProduct *= val
      
    print("Sum of k-minimum prime numbers is", minSum) 
    print("Sum of k-maximum prime numbers is", maxSum) 
    print("Product of k-minimum prime numbers is", minProduct)
    print("Product of k-maximum prime numbers is", maxProduct) 
  
# Driver code 
arr = [ 4, 2, 12, 13, 5, 19 ]
n = len(arr)
k = 3
primeSumAndProduct(arr, n, k)
  
# This code is contributed by ankush_953

chevron_right


Output:

Sum of k-minimum prime numbers is 20
Sum of k-maximum prime numbers is 37
Product of k-minimum prime numbers is 130
Product of k-maximum prime numbers is 1235

competitive-programming-img

My Personal Notes arrow_drop_up
Recommended Articles
Page :