C＃で整数の配列を合計する方法

そこにあるより良い配列を反復処理よりも短い方法は？

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

説明：

プライマリが優れているということは、コードがよりクリーンであることを意味しますが、パフォーマンスの向上に関するヒントも歓迎します。（すでに述べたように：大きな配列の分割）。

それは私がキラーパフォーマンスの改善を探していたようではありません-この非常に種類の構文糖がまだ利用可能ではないのか疑問に思いました： "String.Joinがあります-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ループを使用してインデックスが不足しないようにすることをお勧めします。

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);
});

上記のforループソリューションの1つの問題は、次の入力配列がすべて正の値の場合、合計結果が負になることです。

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

正の結果はintデータ型には大きすぎて負の値にオーバーフローするため、合計は-2147483648です。

同じ入力配列の場合、arr.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などの符号なし整数データ型の配列の場合、合計にunsigned long（ulong）を使用すると、オーバーフロー例外を回避できます。

forループソリューションは、Linq .Sum（）よりも何倍も高速です。

さらに高速に実行するために、HPCsharp nugetパッケージは、これらすべての.Sum（）バージョン、SIMD / SSEバージョン、およびマルチコアパラレルバージョンを実装しており、何倍も高速なパフォーマンスを実現します。

foreachを使用するとコードは短くなりますが、JIT最適化がforループ制御式のLengthとの比較を認識した後、実行時におそらく同じ手順を実行します。

私が使用した私のアプリの1つで：

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

Theodor Zouliasの素晴らしいマルチコアParallel.ForEach実装の改善：

    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