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

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

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]);
    }
}