Related Articles

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

• Difficulty Level : Easy
• Last Updated : 14 Oct, 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 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up