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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!