Bagaimana cara meringkas elemen-elemen dari vektor C ++?

Apa cara yang baik untuk menemukan jumlah semua elemen dalam std::vector?

Misalkan saya memiliki vektor std::vector<int> vectordengan beberapa elemen di dalamnya. Sekarang saya ingin mencari jumlah semua elemen. Apa cara yang berbeda untuk hal yang sama?

Sebenarnya ada beberapa metode.

int sum_of_elems = 0;

C ++ 03

1. Klasik untuk loop:

   for(std::vector<int>::iterator it = vector.begin(); it != vector.end(); ++it)
       sum_of_elems += *it;

2. Menggunakan algoritma standar:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(), 0);

   Catatan Penting: Jenis argumen terakhir digunakan tidak hanya untuk nilai awal, tetapi untuk jenis hasil juga. Jika Anda meletakkan int di sana, int akan mengakumulasikan bahkan jika vektor telah mengambang. Jika Anda menjumlahkan angka floating-point, ubah 0ke 0.0atau 0.0f(terima kasih kepada nneonneo). Lihat juga solusi C ++ 11 di bawah ini.

C ++ 11 dan lebih tinggi

2. b. Secara otomatis melacak jenis vektor bahkan jika terjadi perubahan di masa depan:

   #include <numeric>
   
   sum_of_elems = std::accumulate(vector.begin(), vector.end(),
                                  decltype(vector)::value_type(0));

3. Menggunakan std::for_each:

   std::for_each(vector.begin(), vector.end(), [&] (int n) {
       sum_of_elems += n;
   });

4. Menggunakan rentang berbasis untuk loop (terima kasih kepada Roger Pate):

   for (auto& n : vector)
       sum_of_elems += n;

Cara termudah adalah dengan menggunakan std:accumuatedari vector<int> A:

#include <numeric>
cout << accumulate(A.begin(), A.end(), 0);

Prasoon telah menawarkan sejumlah cara yang berbeda (dan bagus) untuk melakukan ini, tidak ada yang perlu diulang di sini. Saya ingin menyarankan pendekatan alternatif untuk kecepatan.

Jika Anda akan melakukan ini sedikit, Anda mungkin ingin mempertimbangkan "sub-classing" vektor Anda sehingga sejumlah elemen dipertahankan secara terpisah ( sebenarnya bukan sub-classing vector yang rapuh karena kurangnya destructor virtual - Saya berbicara lebih banyak tentang kelas yang berisi jumlah dan vektor di dalamnya, has-adaripada is-a, dan menyediakan metode seperti vektor).

Untuk vektor kosong, jumlahnya diatur ke nol. Pada setiap penyisipan ke vektor, tambahkan elemen yang dimasukkan ke jumlah. Pada setiap penghapusan, kurangi. Pada dasarnya, apa pun yang dapat mengubah vektor yang mendasarinya disadap untuk memastikan jumlah dijaga konsisten.

Dengan begitu, Anda memiliki metode O (1) yang sangat efisien untuk "menghitung" jumlah pada setiap saat (hanya mengembalikan jumlah yang saat ini dihitung). Penyisipan dan penghapusan akan memakan waktu sedikit lebih lama saat Anda menyesuaikan total dan Anda harus mempertimbangkan kinerja ini.

Vektor di mana jumlah dibutuhkan lebih sering daripada vektor diubah adalah yang kemungkinan mendapat manfaat dari skema ini, karena biaya perhitungan jumlah diamortisasi atas semua akses. Jelas, jika Anda hanya membutuhkan jumlah setiap jam dan vektor berubah tiga ribu kali per detik, itu tidak akan cocok.

Sesuatu seperti ini sudah cukup:

class UberVector:
    private Vector<int> vec
    private int sum

    public UberVector():
        vec = new Vector<int>()
        sum = 0

    public getSum():
        return sum

    public add (int val):
        rc = vec.add (val)
        if rc == OK:
            sum = sum + val
        return rc

    public delindex (int idx):
        val = 0
        if idx >= 0 and idx < vec.size:
            val = vec[idx]
        rc =  vec.delindex (idx)
        if rc == OK:
            sum = sum - val
        return rc

Jelas, itu pseudo-code dan Anda mungkin ingin memiliki lebih banyak fungsi, tetapi itu menunjukkan konsep dasar.

Mengapa melakukan penjumlahan ke depan ketika Anda bisa melakukannya mundur ? Diberikan:

std::vector<int> v;     // vector to be summed
int sum_of_elements(0); // result of the summation

Kita bisa menggunakan subskrip, menghitung mundur:

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v[i-1];

Kita dapat menggunakan "subskrip," yang dicentang jangkauan, menghitung mundur (untuk berjaga-jaga):

for (int i(v.size()); i > 0; --i)
    sum_of_elements += v.at(i-1);

Kita dapat menggunakan iterator terbalik dalam for loop:

for(std::vector<int>::const_reverse_iterator i(v.rbegin()); i != v.rend(); ++i)
    sum_of_elements += *i;

Kita bisa menggunakan forward iterator, iterasi mundur, dalam for loop (oooh, tricky!):

for(std::vector<int>::const_iterator i(v.end()); i != v.begin(); --i)
    sum_of_elements += *(i - 1);

Kita dapat menggunakan accumulatedengan iterator terbalik:

sum_of_elems = std::accumulate(v.rbegin(), v.rend(), 0);

Kita dapat menggunakan for_eachdengan ekspresi lambda menggunakan iterator terbalik:

std::for_each(v.rbegin(), v.rend(), [&](int n) { sum_of_elements += n; });

Jadi, seperti yang Anda lihat, ada banyak cara untuk menjumlahkan vektor ke belakang sama halnya dengan menjumlahkan vektor ke depan, dan beberapa di antaranya jauh lebih menarik dan menawarkan peluang yang jauh lebih besar untuk kesalahan satu per satu.

#include<boost/range/numeric.hpp>
int sum = boost::accumulate(vector, 0);

Anda juga bisa menggunakan std::valarray<T>seperti ini

#include<iostream>
#include<vector>
#include<valarray>

int main()
{
    std::vector<int> seq{ 1,2,3,4,5,6,7,8,9,10 };
    std::valarray<int> seq_add{ seq.data(), seq.size() };
    std::cout << "sum = " << seq_add.sum() << "\n";

    return 0;
}

Beberapa mungkin tidak menemukan cara ini efisien karena ukuran valarraykebutuhan harus sebesar ukuran vektor dan inisialisasi valarrayjuga akan memakan waktu.

Dalam hal itu, jangan gunakan dan anggap sebagai cara lain untuk menyimpulkan urutannya.

C ++ 0x saja:

vector<int> v; // and fill with data
int sum {}; // or = 0 ... :)
for (int n : v) sum += n;

Ini mirip dengan BOOST_FOREACH yang disebutkan di tempat lain dan memiliki manfaat kejelasan yang sama dalam situasi yang lebih kompleks, dibandingkan dengan functor stateful yang digunakan dengan akumulasi atau for_each.

Saya pengguna Perl, permainan yang kami miliki adalah menemukan setiap cara berbeda untuk meningkatkan variabel ... itu tidak terlalu berbeda di sini. Jawaban untuk berapa banyak cara untuk menemukan jumlah elemen vektor di C ++ mungkin an infinity...

2 sen saya:

Menggunakan BOOST_FOREACH, untuk mendapatkan sintaks iterator jelek:

sum = 0;
BOOST_FOREACH(int & x, myvector){
  sum += x;
}

iterasi pada indeks (sangat mudah dibaca).

int i, sum = 0;
for (i=0; i<myvector.size(); i++){
  sum += myvector[i];
}

Yang lain ini destruktif, mengakses vektor seperti tumpukan:

while (!myvector.empty()){
   sum+=myvector.back();
   myvector.pop_back();
}

Saya menemukan cara termudah untuk menemukan jumlah semua elemen vektor

#include <iostream>
#include<vector>
using namespace std;

int main()
{
    vector<int>v(10,1);
    int sum=0;
    for(int i=0;i<v.size();i++)
    {
        sum+=v[i];
    }
    cout<<sum<<endl;

}

Dalam program ini, saya memiliki vektor ukuran 10 dan diinisialisasi dengan 1. Saya telah menghitung jumlah dengan loop sederhana seperti dalam array.

Ini mudah. C ++ 11 menyediakan cara mudah untuk meringkas elemen vektor.

sum = 0; 
vector<int> vec = {1,2,3,4,5,....}
for(auto i:vec) 
   sum+=i;
cout<<" The sum is :: "<<sum<<endl;