วิธีการสรุปอาร์เรย์ของจำนวนเต็มใน C #

มีวิธีที่สั้นกว่าที่ดีกว่าการวนซ้ำบนอาร์เรย์หรือไม่?

int[] arr = new int[] { 1, 2, 3 };
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}

ชี้แจง:

รหัสหลักที่ดีกว่าหมายถึงรหัสที่สะอาดกว่า แต่ยินดีต้อนรับคำแนะนำในการปรับปรุงประสิทธิภาพ (เช่นเดียวกับที่กล่าวไปแล้ว: การแยกอาร์เรย์ขนาดใหญ่)

มันไม่เหมือนกับว่าฉันกำลังมองหาการปรับปรุงประสิทธิภาพของนักฆ่า - ฉันแค่สงสัยว่าน้ำตาลวากยสัมพันธ์แบบนี้ไม่มีอยู่แล้ว: "มี String เข้าร่วม - ห่าอะไรเกี่ยวกับ int []?"

โดยมีเงื่อนไขว่าคุณสามารถใช้. NET 3.5 (หรือใหม่กว่า) และ LINQ ได้ลอง

int sum = arr.Sum();

ใช่มี. ด้วย. NET 3.5:

int sum = arr.Sum();
Console.WriteLine(sum);

หากคุณไม่ได้ใช้. NET 3.5 คุณสามารถทำได้:

int sum = 0;
Array.ForEach(arr, delegate(int i) { sum += i; });
Console.WriteLine(sum);

ด้วย LINQ:

arr.Sum()

ขึ้นอยู่กับว่าคุณกำหนดอย่างไรดีกว่า หากคุณต้องการให้โค้ดดูสะอาดขึ้นคุณสามารถใช้. sum () ตามที่กล่าวไว้ในคำตอบอื่น ๆ หากคุณต้องการให้การดำเนินการทำงานอย่างรวดเร็วและคุณมีอาร์เรย์ขนาดใหญ่คุณสามารถทำให้การดำเนินการขนานกันได้โดยการแบ่งออกเป็นผลรวมย่อยแล้วรวมผลลัพธ์

อีกทางเลือกหนึ่งคือใช้Aggregate()วิธีการขยาย

var sum = arr.Aggregate((temp, x) => temp+x);

หากคุณไม่ชอบ LINQ ควรใช้ foreach loop เพื่อหลีกเลี่ยงดัชนี

int[] arr = new int[] { 1, 2, 3 };
int sum = 0;
foreach (var item in arr)
{
   sum += item;
}

สำหรับอาร์เรย์ที่มีขนาดใหญ่มากอาจต้องเสียค่าใช้จ่ายในการคำนวณโดยใช้โปรเซสเซอร์ / คอร์ของเครื่องมากกว่าหนึ่งตัว

long sum = 0;
var options = new ParallelOptions()
    { MaxDegreeOfParallelism = Environment.ProcessorCount };
Parallel.ForEach(Partitioner.Create(0, arr.Length), options, range =>
{
    long localSum = 0;
    for (int i = range.Item1; i < range.Item2; i++)
    {
        localSum += arr[i];
    }
    Interlocked.Add(ref sum, localSum);
});

ปัญหาหนึ่งของการแก้ปัญหาสำหรับลูปข้างต้นคือสำหรับอาร์เรย์อินพุตต่อไปนี้ที่มีค่าบวกทั้งหมดผลรวมจะเป็นลบ:

int[] arr = new int[] { Int32.MaxValue, 1 };
int sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}
Console.WriteLine(sum);

ผลรวมคือ -2147483648 เนื่องจากผลลัพธ์ที่เป็นบวกนั้นใหญ่เกินไปสำหรับชนิดข้อมูล int และล้นเป็นค่าลบ

สำหรับอาร์เรย์อินพุตเดียวกันคำแนะนำ arr.Sum () ทำให้เกิดข้อยกเว้นล้น

วิธีแก้ปัญหาที่มีประสิทธิภาพมากขึ้นคือการใช้ประเภทข้อมูลที่ใหญ่กว่าเช่น "long" ในกรณีนี้สำหรับ "sum" ดังนี้:

int[] arr = new int[] { Int32.MaxValue, 1 };
long sum = 0;
for (int i = 0; i < arr.Length; i++)
{
    sum += arr[i];
}

การปรับปรุงเดียวกันนี้ใช้ได้กับการสรุปข้อมูลประเภทจำนวนเต็มอื่น ๆ เช่น short และ sbyte สำหรับอาร์เรย์ของชนิดข้อมูลจำนวนเต็มที่ไม่ได้ลงชื่อเช่น uint, ushort และ byte โดยใช้ long ที่ไม่ได้ลงชื่อ (ulong) สำหรับผลรวมจะหลีกเลี่ยงข้อยกเว้นล้น

โซลูชันสำหรับลูปยังเร็วกว่า Linq .um () หลายเท่า

เพื่อให้ทำงานได้เร็วยิ่งขึ้นแพ็คเกจ HPCsharp nuget จะใช้งานทั้งหมดนี้เวอร์ชัน sum () เช่นเดียวกับเวอร์ชัน SIMD / SSE และแบบขนานแบบมัลติคอร์เพื่อประสิทธิภาพที่เร็วขึ้นหลายเท่า

การใช้ foreach จะเป็นโค้ดที่สั้นกว่า แต่อาจทำตามขั้นตอนเดียวกันกับรันไทม์หลังจากการปรับให้เหมาะสม JIT รับรู้การเปรียบเทียบกับความยาวในนิพจน์การควบคุม for-loop

ในแอปหนึ่งของฉันฉันใช้:

public class ClassBlock
{
    public int[] p;
    public int Sum
    {
        get { int s = 0;  Array.ForEach(p, delegate (int i) { s += i; }); return s; }
    }
}

การปรับปรุง Parallel แบบหลายคอร์ที่ดีของ Theodor Zoulias สำหรับการใช้งานแต่ละครั้ง:

    public static ulong SumToUlongPar(this uint[] arrayToSum, int startIndex, int length, int degreeOfParallelism = 0)
    {
        var concurrentSums = new ConcurrentBag<ulong>();

        int maxDegreeOfPar = degreeOfParallelism <= 0 ? Environment.ProcessorCount : degreeOfParallelism;
        var options = new ParallelOptions() { MaxDegreeOfParallelism = maxDegreeOfPar };

        Parallel.ForEach(Partitioner.Create(startIndex, startIndex + length), options, range =>
        {
            ulong localSum = 0;
            for (int i = range.Item1; i < range.Item2; i++)
                localSum += arrayToSum[i];
            concurrentSums.Add(localSum);
        });

        ulong sum = 0;
        var sumsArray = concurrentSums.ToArray();
        for (int i = 0; i < sumsArray.Length; i++)
            sum += sumsArray[i];

        return sum;
    }

ซึ่งใช้ได้กับชนิดข้อมูลจำนวนเต็มที่ไม่ได้ลงชื่อเนื่องจาก C # รองรับเฉพาะ Interlocked เท่านั้น Add () สำหรับ int และ long การใช้งานข้างต้นยังสามารถแก้ไขได้อย่างง่ายดายเพื่อรองรับชนิดข้อมูลจำนวนเต็มและทศนิยมอื่น ๆ เพื่อทำการสรุปแบบขนานโดยใช้หลายคอร์ของ CPU ใช้ในแพ็คเกจ HPCsharp nuget

ลองใช้รหัสนี้:

using System;

namespace Array
{
    class Program
    {
        static void Main()
        {
            int[] number = new int[] {5, 5, 6, 7};

            int sum = 0;
            for (int i = 0; i <number.Length; i++)
            {
                sum += number[i];
            }
            Console.WriteLine(sum);
        }
    }
} 

ผลลัพธ์คือ:

23