Smallest subarray with sum greater than or equal to K

using System;

class Program
{
    // Function to find the smallest subarray with sum greater than or equal to K
    static int FindSubarray(int[] arr, int n, int k)
    {
        // For storing the minimum length of those subarrays 
        // that have a sum greater than or equal to K
        int ans = int.MaxValue;

        for (int i = 0; i < n; i++)
        {
            // For the sum of all elements of the subarray
            int sum = 0;
            
            // For the length of the subarray
            int count = 0;
            
            for (int j = i; j < n; j++)
            {
                count++;
                sum += arr[j];
                
                if (sum >= k)
                {
                    if (count < ans)
                    {
                        ans = count;
                    }
                }
            }
        }

        // When no such subarray exists
        if (ans == int.MaxValue)
        {
            return -1;
        }

        return ans;
    }

    // Driver Code
    static void Main(string[] args)
    {
        int[] arr = { 2, 1, 1, -4, 3, 1, -1, 2 };
        int k = 5;
        int n = arr.Length;
        Console.WriteLine(FindSubarray(arr, n, k));
    }
}

//C# code
using System;
using System.Collections.Generic;
using System.Linq;

namespace MainProgram
{
    class MainClass
    {
        // Function to perform Binary Search
        // and return the smallest index with
        // sum greater than value
        public static int binary_search(SortedDictionary<int, List<int>> m, int value, int index)
        {
            // Search the value in map
            KeyValuePair<int, List<int>> it = m.FirstOrDefault(x => x.Key >= value);

            // If all keys in the map
            // are less than value
            if (it.Equals(default(KeyValuePair<int, List<int>>)))
                return 0;

            // Check if the sum is found
            // at a greater index
            List<int> list = it.Value;
            int i = list.BinarySearch(index);

            if (i >= 0)
                return list[i];

            return -i - 1 < list.Count ? list[-i - 1] : 0;
        }

        // Function to find the smallest subarray
        // with sum greater than equal to K
        public static int findSubarray(int[] arr, int n, int k)
        {
            // Prefix sum array
            int[] pre_array = new int[n];

            // Stores the hashes to prefix sum
            SortedDictionary<int, List<int>> m = new SortedDictionary<int, List<int>>();

            pre_array[0] = arr[0];
            List<int> l = new List<int>();
            l.Add(0);
            m.Add(pre_array[0], l);

            // If any array element is
            // greater than equal to k
            if (arr[0] >= k)
                return 1;

            int ans = Int32.MaxValue;
            for (int i = 1; i < n; i++)
            {

                pre_array[i]
                  = arr[i] + pre_array[i - 1];

                // If prefix sum exceeds K
                if (pre_array[i] >= k)

                    // Update size of subarray
                    ans = Math.Min(ans, i + 1);

                KeyValuePair<int, List<int>> it = m.Last();

                // Hash prefix sum in
                // increasing order
                if (pre_array[i] >= it.Key)
                {
                    if (m.ContainsKey(pre_array[i]))
                    {
                        m[pre_array[i]].Add(i);
                    }
                    else
                    {
                        m.Add(pre_array[i], new List<int> { i });
                    }
                }
            }

            for (int i = 1; i < n; i++)
            {

                int temp
                  = binary_search(m,
                                  pre_array[i - 1] + k,
                                  i);
                if (temp == 0)
                    continue;

                // Update size of subarray
                ans = Math.Min(ans, temp - i + 1);
            }

            // If any subarray is found
            if (ans <= n)
                return ans;

            // If no such subarray exists
            return -1;
        }

        // Driver Code
        public static void Main(string[] args)
        {
            int[] arr = { 2, 1, 1, -4, 3, 1, -1, 2 };

            int k = 5;

            int n = arr.Length;

            Console.WriteLine(findSubarray(arr, n, k));
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static int GetShortestSubarray(List<int> A, int X)
    {
        int ans = int.MaxValue;
        int n = A.Count;
        // List to store prefix sums
        List<long> prefSum = new List<long>(n);
        // Deque storing index of increasing order prefix sums
        Queue<int> dq = new Queue<int>();

        for (int i = 0; i < n; i++)
        {
            prefSum.Add(A[i] + (i == 0 ? 0 : prefSum[i - 1]));
            if (prefSum[i] >= X)
                ans = Math.Min(ans, i + 1);
        }

        for (int i = 0; i < n; i++)
        {
            // Check if the subarray ending at i has sum at least X
            while (dq.Count > 0 && prefSum[i] - prefSum[dq.Peek()] >= X)
            {
                ans = Math.Min(ans, i - dq.Dequeue());
            }

            // Make the deque store prefix sums in increasing order
            while (dq.Count > 0 && prefSum[dq.Peek()] >= prefSum[i])
            {
                dq.Dequeue();
            }

            dq.Enqueue(i);
        }

        return ans == int.MaxValue ? -1 : ans;
    }

    static void Main()
    {
        List<int> A = new List<int> { 10, 20, -25, 5, 35 };
        int X = 40;
        Console.WriteLine(GetShortestSubarray(A, X));
    }
}