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

• Difficulty Level : Easy
• Last Updated : 28 Dec, 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 composite numbers in the array.
Assume that there are at least k composite numbers in the array.
Examples:

Input: arr[] = {2, 5, 6, 8, 10, 11}, k = 2
Output: Sum of k-minimum composite numbers is 14
Sum of k-maximum composite numbers is 18
Product of k-minimum composite numbers is 48
Product of k-maximum composite numbers is 80
{6, 8, 10} are the only comsposite numbers from the array. {6, 8} are the 2 smallest and {8, 10} are the 2 largest among them.
Input: arr[] = {6, 4, 2, 12, 13, 5, 19, 10}, k = 3
Output: Sum of k-minimum composite numbers is 20
Sum of k-maximum composite numbers is 28
Product of k-minimum composite numbers is 240
Product of k-maximum composite numbers is 720

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 composite or not.
2. Also set 0 and 1 as prime so that they don’t get counted as composite numbers.
3. Now traverse the array and insert all the numbers which are composite 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 composite numbers.
5. Do the same with the max heap to get the sum and product of the max k composite 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``// composite 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 composite numbers in an array``void` `compositeSumAndProduct(``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 primes so that``    ``// they don't get counted as``    ``// composite numbers``    ``prime = ``true``;``    ``prime = ``true``;` `    ``// Max Heap to store all the composite numbers``    ``priority_queue<``int``> maxHeap;` `    ``// Min Heap to store all the composite numbers``    ``priority_queue<``int``, vector<``int``>, greater<``int``>>``        ``minHeap;` `    ``// Push all the composite 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 composite numbers is "``         ``<< minSum << ``"\n"``;``    ``cout << ``"Sum of k-maximum composite numbers is "``         ``<< maxSum << ``"\n"``;``    ``cout << ``"Product of k-minimum composite numbers is "``         ``<< minProduct << ``"\n"``;``    ``cout << ``"Product of k-maximum composite numbers is "``         ``<< maxProduct;``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 4, 2, 12, 13, 5, 19 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `k = 3;` `    ``compositeSumAndProduct(arr, n, k);` `    ``return` `0;``}`

## Java

 `// Java program to find the sum and``// product of k smallest and k largest``// composite numbers in an array``import` `java.util.*;` `class` `GFG``{``    ``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``];``        ``Arrays.fill(prime, ``true``);` `        ``for` `(``int` `p = ``2``; p * p <= max_val; p++)``        ``{` `            ``// If prime[p] is not changed, then``            ``// it is a prime``            ``if` `(prime[p])``            ``{` `                ``// 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 composite numbers in an array``    ``static` `void` `compositeSumAndProduct(Integer[] arr,``                                       ``int` `n, ``int` `k)``    ``{` `        ``// Find maximum value in the array``        ``int` `max_val = Collections.max(Arrays.asList(arr));` `        ``// Use sieve to find all prime numbers``        ``// less than or equal to max_val``        ``boolean``[] prime = SieveOfEratosThenes(max_val);` `        ``// Set 0 and 1 as primes so that``        ``// they don't get counted as``        ``// composite numbers``        ``prime[``0``] = ``true``;``        ``prime[``1``] = ``true``;` `        ``// Max Heap to store all the composite numbers``        ``PriorityQueue maxHeap =``                  ``new` `PriorityQueue((x, y) -> y - x);` `        ``// Min Heap to store all the composite numbers``        ``PriorityQueue minHeap = ``new` `PriorityQueue<>();` `        ``// Push all the composite 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``;``        ``Integer lastMin = ``0``, lastMax = ``0``;``        ``while` `(k-- > ``0``)``        ``{``            ``if` `(minHeap.peek() != ``null` `||``                ``maxHeap.peek() != ``null``)``            ``{` `                ``// Calculate the products``                ``minProduct *= minHeap.peek();``                ``maxProduct *= maxHeap.peek();` `                ``// Calculate the sum``                ``minSum += minHeap.peek();``                ``maxSum += maxHeap.peek();` `                ``// Pop the current minimum element``                ``lastMin = minHeap.poll();` `                ``// Pop the current maximum element``                ``lastMax = maxHeap.poll();``            ``}``            ``else``            ``{` `                ``// when maxHeap or minHeap is exhausted``                ``// then this condition will run``                ``minProduct *= lastMin;``                ``maxProduct *= lastMax;` `                ``minSum += lastMin;``                ``maxSum += lastMax;``            ``}``        ``}` `        ``System.out.println(``"Sum of k-minimum composite"` `+``                                ``" numbers is "` `+ minSum);``        ``System.out.println(``"Sum of k-maximum composite"` `+``                                ``" numbers is "` `+ maxSum);``        ``System.out.println(``"Product of k-minimum composite"` `+``                                ``" numbers is "` `+ minProduct);``        ``System.out.println(``"Product of k-maximum composite"` `+``                                ``" numbers is "` `+ maxProduct);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``Integer[] arr = { ``4``, ``2``, ``12``, ``13``, ``5``, ``19` `};``        ``int` `n = arr.length;``        ``int` `k = ``3``;` `        ``compositeSumAndProduct(arr, n, k);``    ``}``}` `// This code is contributed by``// sanjeev2552`

Output:

```Sum of k-minimum composite numbers is 28
Sum of k-maximum composite numbers is 20
Product of k-minimum composite numbers is 576
Product of k-maximum composite numbers is 192```

My Personal Notes arrow_drop_up