Welcome to the Lounge

Mark_Wallace wrote:

Or even Uranus from urea

glennPattonInThePubAGAIN wrote:

It seems that you can do some stuff in a different style, mostly...

static int maxLength(int[] a, int k)
{
    // The example, subarrays of [1,2,3] is wrong!!!
    // It is missing subarray of 3!!!
    // As usual, these tests are wrong!!!

    // Anyways, this is a fairly inefficient algorithm as it gets all the subarrays first,
    // and the max length, if == a.Length, could stop the search early, and could test if sum > k
    // as the subarrays are parsed, and ignore subarrays whose length is less than the working max.
    List<int[]> subArrays = GetSubArrays(a);
    int max = 0;

    for (int n = 0; n < subArrays.Count; n++)
    {
        if (subArrays[n].Sum() <= k)
        {
            if (subArrays[n].Length > max)
            {
                max = subArrays[n].Length;
            }
        }
    }

    return max;
}

static List<int[]> GetSubArrays(int[] a)
{
    int l = 0;      // Start with length of 1 (0 based indexing!)
    List<int[]> subarrays = new List<int[]>();

    // Iterate, starting with a subarray of length 1.
    while (l < a.Length)
    {
        int idx = 0;

        // Get the subarray components for the given length l
        while (idx + l < a.Length)
        {
            int[] sub = new int[l+1];

            for (int i = 0; i <= l; i++)
            {
                sub[i] = a[idx + i];
            }

            ++idx;

            subarrays.Add(sub);
        }

        ++l;        // next we get subarrays of length 2, then length 3, etc.
    }

    return subarrays;
}

public int[] GetMostCommonInts(int[] input)
       {
           if (input == null)
           {
               return input;
           }
           else if (input.Length == 0)
           {
               return input;
           }
           else
           {
               var groups = input.GroupBy(x => x);
               Dictionary<int, int> dictInputCount = groups.ToDictionary(res => res.Key, res => res.Count());

               int[] resultInts = dictInputCount.Where(x => x.Value == dictInputCount.Max(y => y.Value))
                   .Select(x => x.Key)
                   .OrderBy(x => x)
                   .ToArray();

               return resultInts;
           }