using System;

using System.Diagnostics;

using System.Collections.Generic;

using System.Collections;

using System.Threading.Tasks;

​

// Solution code goes her

public interface IAggregate

{

    Dictionary<string, double>[] DoAggregations(double[,] input);

}

​

public class Solution: IAggregate

{

    public const string SUM="SUM";

    public const string AVERAGE = "AVERAGE";

    public const string COUNT_DISTINCT = "COUNT DISTINCT";

    public Dictionary<string, double>[] DoAggregations(double[,] input)

    {

​

        Dictionary<string, double>[] result = new Dictionary<string, double>[input.GetLength(1)];

        Dictionary<string, double> temp;

​

        for (int i = 0; i < input.GetLength(0); i++)

        {

​

            for (int j = 0; j < input.GetLength(1); j++)

            {

​

                temp = result[j];

​

                if (temp == null) temp = new Dictionary<string, double>();

​

                if (temp.ContainsKey(SUM))

                    temp[SUM] += input[i, j];

                else

                {

                    temp.Add(SUM, input[i, j]);

                    result[j] = temp;

                }

​

            }

​

        }

​

        for (int i = 0; i < result.Length; i++)

        {

            temp = result[i];

            if (temp.ContainsKey(SUM))

            {

                temp[AVERAGE] = temp[SUM] / input.GetLength(0);

            }

        }

​

        for (int i = 0; i < input.GetLength(1); i++)

        {

            Hashtable count = new Hashtable();

            for (int j = 0; j < input.GetLength(0); j++)

            {

                double currentValue = input[j, i];

                if (!count.ContainsKey(currentValue))

                {

                    count.Add(currentValue, 1);

                }

​

            }

            temp = result[i];

            temp[COUNT_DISTINCT] = count.Count;

        }

​

​

        return result;

    }

}

public class Generic : IAggregate

{

    public const string SUM = "SUM";

    public const string AVERAGE = "AVERAGE";

    public const string COUNT_DISTINCT = "COUNT DISTINCT";

    public static Dictionary<string, double>[] DoAggregations(Func<double[,], Dictionary<string, double>[]> Func, double[,] input)

    {

        return Func(input);

    }

    public Dictionary<string, double>[] DoAggregations(double[,] input)

    {

        return Generic.DoAggregations((x) => {

​

            Dictionary<string, double>[] result = new Dictionary<string, double>[input.GetLength(1)];

            Dictionary<string, double> temp;

​

            for (int i = 0; i < input.GetLength(0); i++)

            {

​

                for (int j = 0; j < input.GetLength(1); j++)

                {

​

                    temp = result[j];

​

                    if (temp == null) temp = new Dictionary<string, double>();

​

                    if (temp.ContainsKey(SUM))

                        temp[SUM] += input[i, j];

                    else

                    {

                        temp.Add(SUM, input[i, j]);

                        result[j] = temp;

                    }

                }

​

            }

​

            for (int i = 0; i < result.Length; i++)

            {

                temp = result[i];

                if (temp.ContainsKey(SUM))

                {

                    temp[AVERAGE] = temp[SUM] / input.GetLength(0);

                }

            }

​

            for (int i = 0; i < input.GetLength(1); i++)

            {

                Hashtable count = new Hashtable();

                for (int j = 0; j < input.GetLength(0); j++)

                {

                    double currentValue = input[j,i];

                    if (!count.ContainsKey(currentValue))

                    {

                        count.Add(currentValue,1);

                    }

                }

                temp = result[i];

                temp[COUNT_DISTINCT] = count.Count;

            }

​

​

            return result;

​

​

        }, input);

    }

}

public class Mock : IAggregate

{

    public  Dictionary<string, double>[] DoAggregations(double[,] input)

    {

        return new Dictionary<string, double>[]{

            new Dictionary<string, double>{{"SUM", 9d}, {"AVERAGE", 2.25d}, {"COUNT DISTINCT", 3d}},

            new Dictionary<string, double>{{"SUM", 14d}, {"AVERAGE", 3.5d}, {"COUNT DISTINCT", 2d}},

            new Dictionary<string, double>{{"SUM", 16d}, {"AVERAGE", 4d}, {"COUNT DISTINCT", 4d}}};

    }

}

​

public class Program

{

    // Don't change Main

    public static void Main()

    {

​

        //*** SMALL INPUT ***//

        double[,] smallInput = new double[,] { { 1, 4, 3 }, { 2, 3, 4 }, { 1, 3, 7 }, { 5, 4, 2 } };

​

        // Mocked example of execution

        IAggregate aggregate = new Mock();

        Console.WriteLine("=== Small Input - Mocked Execution ===");

        var mockResult = aggregate.DoAggregations(smallInput);

        IsResultCorrect(mockResult);

​

        // Your code execution

        aggregate = new Generic();

        Console.WriteLine("\n=== Small Input - Solution Execution ===");

        var result = aggregate.DoAggregations( smallInput);

        IsResultCorrect(result);

​

        //*** LARGE INPUT ***//

        Console.WriteLine("\n=== Large Input - Solution Execution ===");

        var largeInput = GenerateLargeInput();

        aggregate = new Solution();

        var sw = Stopwatch.StartNew();

        Parallel.For(0, 5, i =>

        {

            aggregate.DoAggregations(largeInput);

        });

​

        sw.Stop();

        IsExecutionFastEnough(sw.ElapsedMilliseconds / 5);

    }

    public static double[,] GenerateLargeInput()

    {

        int numRows = 15000;

        int numCols = 100;

​

        var input = new double[numRows, numCols];

        Random rnd = new Random(123);

        for (int col = 0; col < numCols; col++)

            for (int row = 0; row < numRows; row++)

                input[row, col] = rnd.Next(100000);

​

        return input;

    }

​

    public static void IsResultCorrect(Dictionary<string, double>[] result)

    {

        if (

            result[0]["SUM"] == 9d &&

            result[1]["SUM"] == 14d &&

            result[2]["SUM"] == 16d &&

            result[0]["AVERAGE"] == 2.25d &&

            result[1]["AVERAGE"] == 3.5d &&

            result[2]["AVERAGE"] == 4d &&

            result[0]["COUNT DISTINCT"] == 3d &&

            result[1]["COUNT DISTINCT"] == 2d &&

            result[2]["COUNT DISTINCT"] == 4d

        )

        {

            Console.WriteLine("IsResultCorrect Passed");

            return;

        }

​

        Console.WriteLine("IsResultCorrect Failed");

    }

​

    public static void IsExecutionFastEnough(double milliSeconds)

    {

​

        if (milliSeconds < 70)

            Console.WriteLine($"IsExecutionFastEnough DIAMOND!!!: {milliSeconds}ms");

        else if (milliSeconds < 85)

            Console.WriteLine($"IsExecutionFastEnough GOLD!: {milliSeconds}ms");

        else if (milliSeconds < 130)

            Console.WriteLine($"IsExecutionFastEnough SILVER: {milliSeconds}ms");

        else

            Console.WriteLine($"IsExecutionFastEnough BRONZE: {milliSeconds}ms");

    }

}