Cara meringkas array bilangan bulat di C #

Apakah ada cara yang lebih pendek yang lebih baik daripada melakukan iterasi pada array?

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

klarifikasi:

Primer yang lebih baik berarti kode lebih bersih tetapi petunjuk tentang peningkatan kinerja juga diterima. (Seperti yang telah disebutkan: memisahkan array besar).

Ini tidak seperti saya mencari peningkatan kinerja yang mematikan - Saya hanya bertanya-tanya apakah jenis gula sintaksis ini belum tersedia: "Ada String.Join - apa sih int []?".

Asalkan Anda dapat menggunakan .NET 3.5 (atau lebih baru) dan LINQ, coba

int sum = arr.Sum();

Ya ada. Dengan .NET 3.5:

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

Jika Anda tidak menggunakan .NET 3.5 Anda dapat melakukan ini:

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

Dengan LINQ:

arr.Sum()

Itu tergantung pada bagaimana Anda mendefinisikan dengan lebih baik. Jika Anda ingin kode terlihat lebih rapi, Anda dapat menggunakan .Sum () seperti yang disebutkan dalam jawaban lain. Jika Anda ingin operasi berjalan cepat dan Anda memiliki larik yang besar, Anda dapat membuatnya paralel dengan memecahnya menjadi sub-penjumlahan, lalu menjumlahkan hasilnya.

Alternatif juga untuk menggunakan Aggregate()metode ekstensi.

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

Jika Anda tidak menyukai LINQ, lebih baik menggunakan foreach loop untuk menghindari keluarnya indeks.

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

Untuk larik yang sangat besar, mungkin ada gunanya melakukan kalkulasi menggunakan lebih dari satu prosesor / inti mesin.

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

Satu masalah dengan solusi loop for di atas adalah untuk array input berikut dengan semua nilai positif, hasil penjumlahannya negatif:

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

Jumlahnya adalah -2147483648, karena hasil positif terlalu besar untuk tipe data int dan meluap ke nilai negatif.

Untuk larik input yang sama, saran arr.Sum () menyebabkan pengecualian overflow dilemparkan.

Solusi yang lebih tepat adalah dengan menggunakan tipe data yang lebih besar, seperti "long" dalam kasus ini, untuk "sum" sebagai berikut:

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

Perbaikan yang sama berfungsi untuk penjumlahan tipe data integer lainnya, seperti short, dan sbyte. Untuk array tipe data integer unsigned seperti uint, ushort dan byte, menggunakan unsigned long (ulong) untuk jumlah tersebut menghindari pengecualian overflow.

Solusi for loop juga beberapa kali lebih cepat dari Linq .Sum ()

Untuk berjalan lebih cepat, paket nuget HPCsharp mengimplementasikan semua versi .Sum () serta versi SIMD / SSE dan paralel multi-core, untuk kinerja yang berkali-kali lebih cepat.

Menggunakan foreach akan menjadi kode yang lebih pendek, tetapi mungkin melakukan langkah yang persis sama pada waktu proses setelah pengoptimalan JIT mengenali perbandingan dengan Panjang dalam ekspresi pengontrol loop-for.

Di salah satu aplikasi saya, saya menggunakan:

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

Peningkatan pada implementasi Parallel.ForEach multi-core yang bagus dari 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;
    }

yang berfungsi untuk tipe data integer unsigned, karena C # hanya mendukung Interlocked.Add () untuk int dan long. Implementasi di atas juga dapat dengan mudah dimodifikasi untuk mendukung tipe data integer dan floating-point lainnya untuk melakukan penjumlahan secara paralel menggunakan beberapa inti CPU. Ini digunakan dalam paket nuget HPCsharp.

Coba kode ini:

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

Hasilnya adalah:

23