# Sum and product of k smallest and k largest prime numbers in the array

• Difficulty Level : Easy
• Last Updated : 03 Aug, 2021

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

 `// C++ program to find the sum``// and product of k smallest and``// k largest prime numbers in an array``#include ``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 = ``false``;``    ``prime = ``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);` `    ``int` `k = 3;` `    ``primeSumAndProduct(arr, n, k);` `    ``return` `0;``}`

## Java

 `// 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 maxHeap = ``new` `PriorityQueue(Collections.reverseOrder());` `        ``// Min Heap to store all the prime numbers``        ``PriorityQueue minHeap = ``new` `PriorityQueue();` `        ``// 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`

## Python3

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

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

Time Complexity: O(N*log(N) + max_val * log(log(max_val)) ) Where N is the total number of elements and max_val is the maximum value in the array.
Auxiliary Space: O(N + max_val)

My Personal Notes arrow_drop_up