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

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 composite 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[0] = ``true``;``    ``prime[1] = ``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[0]);` `    ``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`

## Python3

 `# Python3 program to find the sum and``# product of k smallest and k largest``# composite numbers in an array``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` `_ ``in` `range``(max_val ``+` `1``)]``    ``for` `p ``in` `range``(``2``, ``1` `+` `int``(max_val ``*``*` `0.5``)):``      ` `        ``# If prime[p] is not changed, then``        ``# it is a prime``        ``if` `prime[p]:` `            ``# Update all multiples of p``            ``for` `i ``in` `range``(``2` `*` `p, max_val ``+` `1``, p):` `                ``prime[i] ``=` `False` `    ``return` `prime` `# Function that calculates the sum``# and product of k smallest and k``# largest composite numbers in an array``def` `compositeSumAndProduct(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 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``    ``maxHeap ``=` `[]` `    ``# Min Heap to store all the composite numbers``    ``minHeap ``=` `[]` `    ``# Push all the composite numbers``    ``# from the array to the heaps``    ``for` `i ``in` `range``(n):``        ``if` `not` `prime[arr[i]]:``            ``minHeap.append(arr[i])``            ``maxHeap.append(arr[i])` `    ``minHeap.sort()``    ``maxHeap.sort(reverse``=``True``)` `    ``minProduct ``=` `1``    ``maxProduct ``=` `1``    ``minSum ``=` `0``    ``maxSum ``=` `0``    ``lastMin ``=` `0``    ``lastMax ``=` `0` `    ``while` `k > ``0``:` `        ``if` `minHeap ``and` `maxHeap:``            ``# Calculate the products``            ``minProduct ``*``=` `minHeap[``0``]``            ``maxProduct ``*``=` `maxHeap[``0``]` `            ``# Calculate the sum``            ``minSum ``+``=` `minHeap[``0``]``            ``maxSum ``+``=` `maxHeap[``0``]` `            ``# Pop the current minimum element``            ``lastMin ``=` `minHeap.pop(``0``)` `            ``# Pop the current maximum element``            ``lastMax ``=` `maxHeap.pop(``0``)` `        ``else``:``            ``minProduct ``*``=` `lastMin``            ``maxProduct ``*``=` `lastMax` `            ``minSum ``+``=` `lastMin``            ``maxSum ``+``=` `lastMax` `        ``k ``-``=` `1` `    ``print``(``"Sum of k-minimum composite numbers is"``, minSum)``    ``print``(``"Sum of k-maximum composite numbers is"``, maxSum)``    ``print``(``"Product of k-minimum composite numbers is"``, minProduct)``    ``print``(``"Product of k-maximum composite numbers is"``, maxProduct)` `# Driver code``arr ``=` `[``4``, ``2``, ``12``, ``13``, ``5``, ``19``]``n ``=` `len``(arr)` `k ``=` `3` `compositeSumAndProduct(arr, n, k)` `# This code is contributed by phasing17`

## C#

 `// C# program to find the sum and ``// product of k smallest and k largest ``// composite numbers in an array ``using` `System;``using` `System.Linq;``using` `System.Collections.Generic;` `class` `GFG``{``  ``static` `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.``    ``bool``[] prime = ``new` `bool``[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]) ``      ``{` `        ``// 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(``int``[] arr, ``                                     ``int` `n, ``int` `k) ``  ``{` `    ``// Find maximum value in the array``    ``int` `max_val = arr.Max();` `    ``// Use sieve to find all prime numbers``    ``// less than or equal to max_val``    ``bool``[] 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``    ``List<``int``> maxHeap = ``      ``new` `List<``int``>();` `    ``// Min Heap to store all the composite numbers``    ``List<``int``> minHeap = ``new` `List<``int``>();` `    ``// 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]);``      ``}``    ``}` `    ``minHeap = minHeap.OrderBy(a => a).ToList();``    ``maxHeap = maxHeap.OrderBy(a => -a).ToList();` `    ``long` `minProduct = 1, maxProduct = 1, ``    ``minSum = 0, maxSum = 0;``    ``int` `lastMin = 0, lastMax = 0;``    ``while` `(k-- > 0) ``    ``{``      ``if` `(minHeap.Count != 0 || ``          ``maxHeap.Count != 0)``      ``{` `        ``// Calculate the products``        ``minProduct *= minHeap[0];``        ``maxProduct *= maxHeap[0];` `        ``// Calculate the sum``        ``minSum += minHeap[0];``        ``maxSum += maxHeap[0];` `        ``// Pop the current minimum element``        ``lastMin = minHeap[0];``        ``minHeap.RemoveAt(0);` `        ``// Pop the current maximum element``        ``lastMax = maxHeap[0];``        ``maxHeap.RemoveAt(0);``      ``} ``      ``else``      ``{` `        ``// when maxHeap or minHeap is exhausted ``        ``// then this condition will run``        ``minProduct *= lastMin;``        ``maxProduct *= lastMax;` `        ``minSum += lastMin;``        ``maxSum += lastMax;``      ``}``    ``}` `    ``Console.WriteLine(``"Sum of k-minimum composite"` `+ ``                      ``" numbers is "` `+ minSum);``    ``Console.WriteLine(``"Sum of k-maximum composite"` `+ ``                      ``" numbers is "` `+ maxSum);``    ``Console.WriteLine(``"Product of k-minimum composite"` `+ ``                      ``" numbers is "` `+ minProduct);``    ``Console.WriteLine(``"Product of k-maximum composite"` `+ ``                      ``" numbers is "` `+ maxProduct);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] arr = { 4, 2, 12, 13, 5, 19 };``    ``int` `n = arr.Length;``    ``int` `k = 3;` `    ``compositeSumAndProduct(arr, n, k);``  ``}``}` `// This code is contributed by``// phasing17`

## Javascript

 `// JS program to find the sum and``// product of k smallest and k largest``// composite numbers in an array``function` `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.``    ``let prime = ``new` `Array(max_val + 1).fill(``true``);``    ``for` `(``var` `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` `(``var` `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``function` `compositeSumAndProduct(arr, n, k)``{``    ``// Find maximum value in the array``    ``let max_val =  Math.max(...arr) ` `    ``// Use sieve to find all prime numbers``    ``// less than or equal to max_val``    ``let 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``    ``let maxHeap = [];` `    ``// Min Heap to store all the composite numbers``    ``let minHeap = [];` `    ``// Push all the composite numbers ``    ``// from the array to the heaps``    ``for` `(``var` `i = 0; i < n; i++)``        ``if` `(!prime[arr[i]]) {``            ``minHeap.push(arr[i]);``            ``maxHeap.push(arr[i]);``        ``}``        ` `    ``minHeap.sort(``function``(a, b) { ``return` `a > b});``    ``maxHeap.sort(``function``(a, b) { ``return` `a < b});` `    ``let minProduct = 1``        ``, maxProduct = 1``        ``, minSum = 0``        ``, maxSum = 0;``    ``while` `(k-- > 0) {``        ` `        ``// Calculate the products``        ``minProduct *= minHeap[0];``        ``maxProduct *= maxHeap[0];` `        ``// Calculate the sum``        ``minSum += minHeap[0];``        ``maxSum += maxHeap[0];` `        ``// Pop the current minimum element``        ``minHeap.shift();` `        ``// Pop the current maximum element``        ``maxHeap.shift();``    ``}` `    ``console.log(``"Sum of k-minimum composite numbers is "``         ``+ minSum)``    ``console.log(``"Sum of k-maximum composite numbers is "``         ``+ maxSum);``    ``console.log(``"Product of k-minimum composite numbers is "``         ``+ minProduct);``    ``console.log(``"Product of k-maximum composite numbers is "``         ``+ maxProduct);` `}` `// Driver code``let arr = [ 6, 4, 2, 12, 13, 5, 19, 10];``let n = arr.length;` `let k = 3;` `compositeSumAndProduct(arr, n, k);` `// This code is contributed by phasing17`

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

### Approach: Heap-based Selection of K-Smallest and K-Largest Composite Numbers

Here are the steps for the “Heap-based Selection of K-Smallest and K-Largest Composite Numbers” approach:

1. Define a function is_composite(n) that takes an integer n as input and returns True if n is composite, i.e., if it has a factor other than 1 and itself.
2. Define a function sum_product_k_smallest_largest_composite(arr, k) that takes an array of integers arr and an integer k as inputs and returns a tuple containing the sum and product of the k smallest and k largest composite numbers in arr.
3. Initialize an empty list composite_nums.
4. Iterate over the integers in arr, and for each integer num, check if it is composite using the is_composite() function. If num is composite, append it to the composite_nums list.
5. Use the heapq.nsmallest(k, composite_nums) function to find the k smallest composite numbers in composite_nums. Assign the result to a variable k_smallest_composites.
6. Use the heapq.nlargest(k, composite_nums) function to find the k largest composite numbers in composite_nums. Assign the result to a variable k_largest_composites.
7. Calculate the sum of the k smallest composite numbers in k_smallest_composites, and assign the result to a variable sum_k_smallest.
8. Calculate the sum of the k largest composite numbers in k_largest_composites, and assign the result to a variable sum_k_largest.
Initialize variables product_k_smallest and product_k_largest to 1.
9. Iterate over the integers in k_smallest_composites, and for each integer num, multiply it with product_k_smallest.
10. Iterate over the integers in k_largest_composites, and for each integer num, multiply it with product_k_largest.
11. Return a tuple containing sum_k_smallest, sum_k_largest, product_k_smallest, and product_k_largest.

## Java

 `// Java equivalent of the above code``import` `java.util.PriorityQueue;` `public` `class` `SumProductKSmallestLargestComposite {` `    ``public` `static` `boolean` `isComposite(``int` `n) {``        ``if` `(n < ``2``) {``            ``return` `false``;``        ``}``        ``for` `(``int` `i = ``2``; i <= Math.sqrt(n); i++) {``            ``if` `(n % i == ``0``) {``                ``return` `true``;``            ``}``        ``}``        ``return` `false``;``    ``}` `    ``public` `static` `int``[] sumProductKSmallestLargestComposite(``int``[] arr, ``int` `k) {``        ``PriorityQueue minHeap = ``new` `PriorityQueue<>();``        ``PriorityQueue maxHeap = ``new` `PriorityQueue<>((a, b) -> (b - a));` `        ``for` `(``int` `num : arr) {``            ``if` `(isComposite(num)) {``                ``minHeap.add(num);``                ``maxHeap.add(num);``            ``}``        ``}` `        ``int` `sumKSmallest = ``0``;``        ``int` `sumKLargest = ``0``;``        ``int` `productKSmallest = ``1``;``        ``int` `productKLargest = ``1``;` `        ``for` `(``int` `i = ``0``; i < k; i++) {``            ``sumKSmallest += minHeap.peek();``            ``sumKLargest += maxHeap.peek();``            ``productKSmallest *= minHeap.poll();``            ``productKLargest *= maxHeap.poll();``        ``}` `        ``return` `new` `int``[] {sumKSmallest, sumKLargest, productKSmallest, productKLargest};``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = {``6``, ``4``, ``2``, ``12``, ``13``, ``5``, ``19``, ``10``};``        ``int` `k = ``3``;``        ``int``[] result = sumProductKSmallestLargestComposite(arr, k);` `        ``System.out.println(``"Sum of k-minimum composite numbers: "` `+ result[``0``]);``        ``System.out.println(``"Sum of k-maximum composite numbers: "` `+ result[``1``]);``        ``System.out.println(``"Product of k-minimum composite numbers: "` `+ result[``2``]);``        ``System.out.println(``"Product of k-maximum composite numbers: "` `+ result[``3``]);``    ``}``}`

## Python3

 `import` `heapq``from` `math ``import` `sqrt` `def` `is_composite(n):``    ``if` `n < ``2``:``        ``return` `False``    ``for` `i ``in` `range``(``2``, ``int``(sqrt(n))``+``1``):``        ``if` `n ``%` `i ``=``=` `0``:``            ``return` `True``    ``return` `False` `def` `sum_product_k_smallest_largest_composite(arr, k):``    ``composite_nums ``=` `[]``    ``for` `num ``in` `arr:``        ``if` `is_composite(num):``            ``composite_nums.append(num)` `    ``k_smallest_composites ``=` `heapq.nsmallest(k, composite_nums)``    ``k_largest_composites ``=` `heapq.nlargest(k, composite_nums)` `    ``sum_k_smallest ``=` `sum``(k_smallest_composites)``    ``sum_k_largest ``=` `sum``(k_largest_composites)` `    ``product_k_smallest ``=` `1``    ``product_k_largest ``=` `1` `    ``for` `num ``in` `k_smallest_composites:``        ``product_k_smallest ``*``=` `num` `    ``for` `num ``in` `k_largest_composites:``        ``product_k_largest ``*``=` `num` `    ``return` `(sum_k_smallest, sum_k_largest, product_k_smallest, product_k_largest)``arr ``=` `[``6``, ``4``, ``2``, ``12``, ``13``, ``5``, ``19``, ``10``]``k ``=` `3` `result ``=` `sum_product_k_smallest_largest_composite(arr, k)` `print``(``"Sum of k-minimum composite numbers:"``, result[``0``])``print``(``"Sum of k-maximum composite numbers:"``, result[``1``])``print``(``"Product of k-minimum composite numbers:"``, result[``2``])``print``(``"Product of k-maximum composite numbers:"``, result[``3``])`

## Javascript

 `function` `is_composite(n) {``    ``if` `(n < 2) {``        ``return` `false``;``    ``}``    ``for` `(let i = 2; i <= Math.sqrt(n); i++) {``        ``if` `(n % i === 0) {``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `function` `sum_product_k_smallest_largest_composite(arr, k) {``    ``let composite_nums = [];``    ``for` `(let num of arr) {``        ``if` `(is_composite(num)) {``            ``composite_nums.push(num);``        ``}``    ``}` `    ``let k_smallest_composites = composite_nums.slice(0).sort((a, b) => a - b).slice(0, k);``    ``let k_largest_composites = composite_nums.slice(0).sort((a, b) => b - a).slice(0, k);` `    ``let sum_k_smallest = k_smallest_composites.reduce((a, b) => a + b, 0);``    ``let sum_k_largest = k_largest_composites.reduce((a, b) => a + b, 0);` `    ``let product_k_smallest = k_smallest_composites.reduce((a, b) => a * b, 1);``    ``let product_k_largest = k_largest_composites.reduce((a, b) => a * b, 1);` `    ``return` `[sum_k_smallest, sum_k_largest, product_k_smallest, product_k_largest];``}` `let arr = [6, 4, 2, 12, 13, 5, 19, 10];``let k = 3;` `let result = sum_product_k_smallest_largest_composite(arr, k);` `console.log(``"Sum of k-minimum composite numbers:"``, result[0]);``console.log(``"Sum of k-maximum composite numbers:"``, result[1]);``console.log(``"Product of k-minimum composite numbers:"``, result[2]);``console.log(``"Product of k-maximum composite numbers:"``, result[3]);`

## C++

 `#include ``#include ``#include ``#include ``#include ` `using` `namespace` `std;` `bool` `isComposite(``int` `n) {``    ``if` `(n < 2) {``        ``return` `false``;``    ``}``    ``for` `(``int` `i = 2; i <= ``sqrt``(n); i++) {``        ``if` `(n % i == 0) {``            ``return` `true``;``        ``}``    ``}``    ``return` `false``;``}` `vector<``int``> sumProductKSmallestLargestComposite(vector<``int``> arr, ``int` `k) {``    ``priority_queue<``int``, vector<``int``>, greater<``int``>> minHeap;``    ``priority_queue<``int``, vector<``int``>, less<``int``>> maxHeap;` `    ``for` `(``int` `num : arr) {``        ``if` `(isComposite(num)) {``            ``minHeap.push(num);``            ``maxHeap.push(num);``        ``}``    ``}` `    ``int` `sumKSmallest = 0;``    ``int` `sumKLargest = 0;``    ``int` `productKSmallest = 1;``    ``int` `productKLargest = 1;` `    ``for` `(``int` `i = 0; i < k; i++) {``        ``sumKSmallest += minHeap.top();``        ``sumKLargest += maxHeap.top();``        ``productKSmallest *= minHeap.top();``        ``productKLargest *= maxHeap.top();``        ``minHeap.pop();``        ``maxHeap.pop();``    ``}` `    ``return` `{sumKSmallest, sumKLargest, productKSmallest, productKLargest};``}` `int` `main() {``    ``vector<``int``> arr = {6, 4, 2, 12, 13, 5, 19, 10};``    ``int` `k = 3;``    ``vector<``int``> result = sumProductKSmallestLargestComposite(arr, k);` `    ``cout << ``"Sum of k-minimum composite numbers: "` `<< result[0] << endl;``    ``cout << ``"Sum of k-maximum composite numbers: "` `<< result[1] << endl;``    ``cout << ``"Product of k-minimum composite numbers: "` `<< result[2] << endl;``    ``cout << ``"Product of k-maximum composite numbers: "` `<< result[3] << endl;` `    ``return` `0;``}`

## C#

 `using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `public` `class` `Program {` `    ``// Function to check if a number n is``    ``// composite or not``    ``public` `static` `bool` `IsComposite(``int` `n)``    ``{``        ``if` `(n < 2) {``            ``return` `false``;``        ``}``        ``for` `(``int` `i = 2; i <= Math.Sqrt(n); i++) {``            ``if` `(n % i == 0) {``                ``return` `true``;``            ``}``        ``}``        ``return` `false``;``    ``}` `    ``// Function to find the sum and product``    ``// of K smallest and largest composite``    ``public` `static` `List<``int``>``    ``SumProductKSmallestLargestComposite(List<``int``> arr,``                                        ``int` `k)``    ``{``        ``List<``int``> compositeNums = ``new` `List<``int``>();``        ``foreach``(``int` `num ``in` `arr)``        ``{``            ``if` `(IsComposite(num)) {``                ``compositeNums.Add(num);``            ``}``        ``}` `        ``List<``int``> kSmallestComposites``            ``= compositeNums.OrderBy(x = > x)``                  ``.Take(k)``                  ``.ToList();``        ``List<``int``> kLargestComposites``            ``= compositeNums.OrderByDescending(x = > x)``                  ``.Take(k)``                  ``.ToList();` `        ``int` `sumKSmallest = kSmallestComposites.Sum();``        ``int` `sumKLargest = kLargestComposites.Sum();` `        ``int` `productKSmallest``            ``= kSmallestComposites.Aggregate((x, y) =``                                                ``> x * y);``        ``int` `productKLargest = kLargestComposites.Aggregate(``            ``(x, y) = > x * y);` `        ``return` `new` `List<``int``>{ sumKSmallest, sumKLargest,``                              ``productKSmallest,``                              ``productKLargest };``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``List<``int``> arr``            ``= ``new` `List<``int``>{ 6, 4, 2, 12, 13, 5, 19, 10 };``        ``int` `k = 3;``        ``List<``int``> result``            ``= SumProductKSmallestLargestComposite(arr, k);` `        ``Console.WriteLine(``            ``"Sum of k-minimum composite numbers: "``            ``+ result[0]);``        ``Console.WriteLine(``            ``"Sum of k-maximum composite numbers: "``            ``+ result[1]);``        ``Console.WriteLine(``            ``"Product of k-minimum composite numbers: "``            ``+ result[2]);``        ``Console.WriteLine(``            ``"Product of k-maximum composite numbers: "``            ``+ result[3]);``    ``}``}`

Output
```Sum of k-minimum composite numbers: 20
Sum of k-maximum composite numbers: 28
Product of k-minimum composite numbers: 240
Product of k-maximum composite numbers: 720```

Time Complexity: O(n * sqrt(max(arr)) + k * log(n))
Auxiliary Space: O(n + k)

Previous
Next