using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Threading.Tasks;

​

public class Program

{

    // Test data for benchmarking

    private static readonly int[] TestIntArray;

    static Program()

    {

        // Create a test array with 10,000 integers

        TestIntArray = new int[10000];

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

        {

            TestIntArray[i] = i;

        }

    }

​

    public static void Main()

    {

        const int iterations = 1000;

        const int warmupIterations = 100;

        // Warmup

        Console.WriteLine("Performing warmup...");

        for (int i = 0; i < warmupIterations; i++)

        {

            BC_Util.ArrayIntToString(TestIntArray);

            BC_Util.ArrayIntToStringLinq(TestIntArray);

            BC_Util.ArrayIntToStringSpan(TestIntArray);

            BC_Util.ArrayIntToStringParallel(TestIntArray);

        }

        Console.WriteLine("Warmup complete.\n");

​

        // Actual benchmarking

        Console.WriteLine($"Running benchmarks ({iterations} iterations each)...");

        var results1 = BenchmarkMethod("Original", iterations, () => BC_Util.ArrayIntToString(TestIntArray));

        var results2 = BenchmarkMethod("LINQ", iterations, () => BC_Util.ArrayIntToStringLinq(TestIntArray));

        var results3 = BenchmarkMethod("Span", iterations, () => BC_Util.ArrayIntToStringSpan(TestIntArray));

        var results4 = BenchmarkMethod("Parallel", iterations, () => BC_Util.ArrayIntToStringParallel(TestIntArray));

​

        // Collect memory usage

        var mem1 = MeasureMemoryUsage(() => BC_Util.ArrayIntToString(TestIntArray));

        var mem2 = MeasureMemoryUsage(() => BC_Util.ArrayIntToStringLinq(TestIntArray));

        var mem3 = MeasureMemoryUsage(() => BC_Util.ArrayIntToStringSpan(TestIntArray));

        var mem4 = MeasureMemoryUsage(() => BC_Util.ArrayIntToStringParallel(TestIntArray));

​

        // Store results in a list for sorting

        var allResults = new List<(string Name, double AvgTime, long Memory)>

        {

            ("Original", results1.Average, mem1),

            ("LINQ", results2.Average, mem2),

            ("Span", results3.Average, mem3),

            ("Parallel", results4.Average, mem4)

        };

​

        // Sort by average time (fastest first)

        var sortedByTime = allResults.OrderBy(r => r.AvgTime).ToList();

        // Sort by memory (lowest first)

        var sortedByMemory = allResults.OrderBy(r => r.Memory).ToList();

​

        // Print results

        Console.WriteLine("\n========== SUMMARY ==========");

        Console.WriteLine("\nDetailed Results:");

        Console.WriteLine($"Original - Avg: {results1.Average:F2}ms, Min: {results1.Min:F2}ms, Max: {results1.Max:F2}ms, Memory: {mem1:N0} bytes");

        Console.WriteLine($"LINQ     - Avg: {results2.Average:F2}ms, Min: {results2.Min:F2}ms, Max: {results2.Max:F2}ms, Memory: {mem2:N0} bytes");

        Console.WriteLine($"Span     - Avg: {results3.Average:F2}ms, Min: {results3.Min:F2}ms, Max: {results3.Max:F2}ms, Memory: {mem3:N0} bytes");

        Console.WriteLine($"Parallel - Avg: {results4.Average:F2}ms, Min: {results4.Min:F2}ms, Max: {results4.Max:F2}ms, Memory: {mem4:N0} bytes");

​

        Console.WriteLine("\nPerformance Ranking (Fastest to Slowest):");

        for (int i = 0; i < sortedByTime.Count; i++)

        {

            var item = sortedByTime[i];

            var percentSlower = i == 0 ? 0 : ((item.AvgTime - sortedByTime[0].AvgTime) / sortedByTime[0].AvgTime * 100);

            Console.WriteLine($"{i+1}. {item.Name,-8} - {item.AvgTime:F2}ms {(i == 0 ? "(fastest)" : $"({percentSlower:F2}% slower than fastest)")}");

        }

​

        Console.WriteLine("\nMemory Usage Ranking (Lowest to Highest):");

        for (int i = 0; i < sortedByMemory.Count; i++)

        {

            var item = sortedByMemory[i];

            var percentMore = i == 0 ? 0 : ((item.Memory - sortedByMemory[0].Memory) / (double)sortedByMemory[0].Memory * 100);

            Console.WriteLine($"{i+1}. {item.Name,-8} - {item.Memory:N0} bytes {(i == 0 ? "(lowest)" : $"({percentMore:F2}% more than lowest)")}");

        }

    }

​

    private static (double Average, double Min, double Max) BenchmarkMethod(

        string name, 

        int iterations, 

        Func<string[]> method)

    {

        var times = new double[5]; // Run 5 separate trials

        for (int trial = 0; trial < 5; trial++)

        {

            var sw = Stopwatch.StartNew();

            for (int i = 0; i < iterations; i++)

            {

                method();

            }

            sw.Stop();

            times[trial] = sw.ElapsedMilliseconds;

            Console.WriteLine($"{name,-8} Trial {trial + 1}: {times[trial]:F2}ms");

        }

​

        return (

            Average: times.Average(),

            Min: times.Min(),

            Max: times.Max()

        );

    }

​

    private static long MeasureMemoryUsage(Func<string[]> method)

    {

        const int memoryTestIterations = 5;

        long totalMemoryUsed = 0;

        for (int i = 0; i < memoryTestIterations; i++)

        {

            // Force garbage collection

            GC.Collect();

            GC.WaitForPendingFinalizers();

            GC.Collect();

​

            // Get memory before

            long memoryBefore = GC.GetTotalMemory(true);

            // Run the method

            method();

            // Get memory after

            long memoryAfter = GC.GetTotalMemory(false);

            // Add the difference

            totalMemoryUsed += memoryAfter - memoryBefore;

        }

        // Return the average

        return totalMemoryUsed / memoryTestIterations;

    }

}

​

// The BC_Fmt class that contains the CStr method

public static class BC_Fmt

{

    public static string CStr(int value)

    {

        return value.ToString();

    }

}

​

// Utility class containing the original and optimized methods

public static class BC_Util

{

    // Original method

    public static string[] ArrayIntToString(int[] IntArr)

    {

        if (MultipleSelectedInt(IntArr))

        {

            int length = IntArr.Length;

            string[] strArr = new string[length];

            for (int i = 0; i < length; i++)

            {

                strArr[i] = BC_Fmt.CStr(IntArr[i]);

            }

            return strArr;

        }

        else

        {

            return [];

        }

    }

    // LINQ-based optimization

    public static string[] ArrayIntToStringLinq(int[] IntArr)

    {

        if (MultipleSelectedInt(IntArr))

        {

            return IntArr.Select(i => BC_Fmt.CStr(i)).ToArray();

        }

        else

        {

            return [];

        }

    }

    // Span-based optimization

    public static string[] ArrayIntToStringSpan(int[] IntArr)

    {

        if (MultipleSelectedInt(IntArr))

        {

            int length = IntArr.Length;

            string[] strArr = new string[length];

            // Use Span for better performance

            Span<int> intSpan = IntArr;

            for (int i = 0; i < length; i++)

            {

                strArr[i] = BC_Fmt.CStr(intSpan[i]);

            }

            return strArr;

        }

        else

        {

            return [];

        }

    }

    // Parallel-based optimization

    public static string[] ArrayIntToStringParallel(int[] IntArr)

    {

        if (MultipleSelectedInt(IntArr))

        {

            int length = IntArr.Length;

            string[] strArr = new string[length];

            // Only use parallelism for sufficiently large arrays

            if (length > 1000)

            {

                Parallel.For(0, length, i =>

                {

                    strArr[i] = BC_Fmt.CStr(IntArr[i]);

                });

            }

            else

            {

                for (int i = 0; i < length; i++)

                {

                    strArr[i] = BC_Fmt.CStr(IntArr[i]);

                }

            }

            return strArr;

        }

        else

        {

            return [];

        }

    }

    // Helper method to check if the array has selected integers

    public static bool MultipleSelectedInt(int[] IntArr)

    {

        return IntArr != null && IntArr.Length > 0;

    }

}