Longest subarray having maximum sum

// C# implementation to find 
// the length of the longest 
// subarray having maximum sum 
using System;
using System.Collections.Generic;
public class GFG{ 
    // function to find the 
    // maximum sum that 
    // exists in a subarray 
    static int maxSubArraySum(int []arr, 
                            int size) 
    { 
        int max_so_far = arr[0]; 
        int curr_max = arr[0]; 

        for (int i = 1; i < size; i++) 
        { 
            curr_max = Math.Max(arr[i], 
                            curr_max + arr[i]); 
            max_so_far = Math.Max(max_so_far, 
                                curr_max); 
        } 
        return max_so_far; 
    } 

    // function to find the 
    // length of longest 
    // subarray having sum k 
    static int lenOfLongSubarrWithGivenSum(int []arr, 
                                        int n, int k) 
    { 
        // unordered_map 'um' implemented 
        // as hash table 
        Dictionary<int, 
                int> um = new Dictionary<int, 
                                        int>(); 
        int sum = 0, maxLen = 0; 

        // traverse the given array 
        for (int i = 0; i < n; i++) 
        { 

            // accumulate sum 
            sum += arr[i]; 

            // when subarray starts 
            // from index '0' 
            if (sum == k) 
                maxLen = i + 1; 

            // make an entry for 'sum' if 
            // it is not present in 'um' 
            if (um.ContainsKey(sum)) 
                um.Add(sum, i); 

            // check if 'sum-k' is present 
            // in 'um' or not 
            if (um.ContainsKey(sum - k)) 
            { 

                // update maxLength 
                if (maxLen < (i - um[sum - k])) 
                    maxLen = i - um[sum - k]; 
            } 
        } 

        // required maximum length 
        return maxLen; 
    } 

    // function to find the length 
    // of the longest subarray 
    // having maximum sum 
    static int lenLongSubarrWithMaxSum(int []arr, int n) 
    { 
        int maxSum = maxSubArraySum(arr, n); 
        return lenOfLongSubarrWithGivenSum(arr, n, maxSum); 
    } 

    // Driver Code 
    public static void Main() 
    { 
        int []arr = { 5, -2, -1, 3, -4 }; 
        int n = arr.Length; 
        Console.WriteLine("Length of longest subarray " + 
                                "having maximum sum = " + 
                        lenLongSubarrWithMaxSum(arr, n)); 
    } 
} 

// This code is contributed by Rajput-Ji

using System;

public class GFG
{
    public static int MaxSubArrayLen(int[] arr, int n)
    {
        // Initializing the variables
        int maxSoFar = arr[0];
        int maxEndingHere = arr[0];
        int maxLen = 1;
        int currLen = 1;

        // Traversing through the array to find the subarray
        for (int i = 1; i < n; i++)
        {
            if (maxEndingHere < 0)
            {
                maxEndingHere = arr[i];
                currLen = 1;
            }
            else
            {
                maxEndingHere += arr[i];
                currLen++;
            }

            if (maxEndingHere > maxSoFar)
            {
                maxSoFar = maxEndingHere;
                maxLen = currLen;
            }
            else if (maxEndingHere == maxSoFar)
            {
                maxLen = Math.Max(maxLen, currLen);
            }
        }

        return maxLen;
    }

    // Driver code
    public static void Main(string[] args)
    {
        // Input array
        int[] arr = { 5, -2, -1, 3, -4 };
        int n = arr.Length;
        int maxLen = MaxSubArrayLen(arr, n);
        Console.WriteLine("Length of the subarray with maximum sum = " + maxLen);
    }
}