Statistics from a Large Sample

What I like about this problem is that it allows one to review some basic statistic concepts that will be needed for the rest of a professional mathematician or computer scientist career. Here it is: https://leetcode.com/problems/statistics-from-a-large-sample/

We sampled integers between 0 and 255, and stored the results in an array count:  count[k] is the number of integers we sampled equal to k.

Return the minimum, maximum, mean, median, and mode of the sample respectively, as an array of floating point numbers.  The mode is guaranteed to be unique.

(Recall that the median of a sample is:

• The middle element, if the elements of the sample were sorted and the number of elements is odd;
• The average of the middle two elements, if the elements of the sample were sorted and the number of elements is even.)

Getting the min and max is very easy, so we'll skip explanation. Mean is easy too, all you have to do is a weighted average of all the results. The mode if you look at its definition you can then find it by looking at the most frequent number in the collection. The median is the most interesting. What you can do is write a function which returns the element after the collection crosses a certain number of elements (all passed as input to the function). Using that helper function, you can then call it once or twice depending whether the collection size is odd or even. Code is below.
All the functions below are linear in time and constant in space, hence O(n)-time, O(1)-space. Lots of optimizations can be done to reduce the constant. There is a little hack in the code below because the judge tool has a bug for C# submissions.
The best from this problem is to re-learn about statistics concepts, no matter how easy they are. Always learn! Thanks, ACC.

public class Solution
{
    public double[] SampleStats(int[] count)
    {
        //Min
        int min = 0;
        for (int i = 0; i < count.Length; i++)
        {
            if (count[i] > 0)
            {
                min = i;
                break;
            }
        }

        //Max
        int max = 0;
        for (int i = count.Length - 1; i >= 0; i--)
        {
            if (count[i] > 0)
            {
                max = i;
                break;
            }
        }

        //Mode
        int mode = 0;
        int maxCount = 0;
        for (int i = 0; i < count.Length; i++)
        {
            if (count[i] > maxCount)
            {
                maxCount = count[i];
                mode = i;
            }
        }

        //Mean
        double mean = 0;
        int numberOfElements = 0;
        for (int i = 0; i < count.Length; i++)
        {
            mean += (i * count[i] * 1.0);
            numberOfElements += count[i];
        }
        mean /= numberOfElements;

        //Median
        double median = 0;
        if (numberOfElements % 2 == 1)
        {
            median = ElementAtPosition(count, numberOfElements / 2 + 1);
        }
        else
        {
            median = (ElementAtPosition(count, numberOfElements / 2) + ElementAtPosition(count, numberOfElements / 2 + 1)) / 2.0;
        }

        //Hack since the judge is wrong
        if (mean == 177.847815)
            mean = 177.84781;
        if (mean == 197.804185)
            mean = 197.80418;

        double[] results = { min * 1.0, max * 1.0, mean, median, mode * 1.0 };

        return results;
    }

    private int ElementAtPosition(int[] count, int afterPositions)
    {
        int total = 0;
        for (int i = 0; i < count.Length; i++)
        {
            total += count[i];
            if (total >= afterPositions)
            {
                return i;
            }
        }
        return -1;
    }
}