Как найти сумму в числовом массиве

TL;DR

If you care about performance, define a function that uses a for-loop.

function sum(arr) {
    var res = 0;
    for (var x of arr) {
        res += x;
    }
    return res;
}

Benchmark

I benchmarked a selection of implementations using benchmark.js (typescript version):

const arr = Array.from({ length: 100 }, () => Math.random());
const reducer = function (p: number, a: number) {
    return p + a;
};
const recursion = function (arr: number[], i: number) {
    if(i > 0) return arr[i] + recursion(arr, i - 1)
    else return 0
};
const recursion2 = function (arr: number[], i: number, len: number) {
    if(i < len) return arr[i] +  recursion2(arr, i + 1, len)
    else return 0
};
const recursion3 = function (arr: number[], i: number) {
    if(i < arr.length) return arr[i] + recursion3(arr, i + 1)
    else return 0
};
new Benchmark.Suite()
    .add("jquery", () => {
        let res = 0;
        $.each(arr, (_, x) => (res += x));
    })
    .add("lodash", ()=>_.sum(arr))
    .add("forEach", () => {
        let res = 0;
        arr.forEach((x) => (res += x));
    })
    .add("reduce", () => arr.reduce((p, a) => p + a, 0))
    .add("predefined reduce", () => arr.reduce(reducer, 0))
    .add("eval", () => eval(arr.join("+")))
    .add("recursion", () => recursion(arr, arr.length - 1))
    .add("recursion2", () => recursion2(arr, 0, arr.length))
    .add("recursion3", () => recursion3(arr, 0))
    .add("naive", () => (
        arr[0]+arr[1]+arr[2]+arr[3]+arr[4]+arr[5]+arr[6]+arr[7]+arr[8]+arr[9]+
        arr[10]+arr[11]+arr[12]+arr[13]+arr[14]+arr[15]+arr[16]+arr[17]+arr[18]+arr[19]+
        arr[20]+arr[21]+arr[22]+arr[23]+arr[24]+arr[25]+arr[26]+arr[27]+arr[28]+arr[29]+
        arr[30]+arr[31]+arr[32]+arr[33]+arr[34]+arr[35]+arr[36]+arr[37]+arr[38]+arr[39]+
        arr[40]+arr[41]+arr[42]+arr[43]+arr[44]+arr[45]+arr[46]+arr[47]+arr[48]+arr[49]+
        arr[50]+arr[51]+arr[52]+arr[53]+arr[54]+arr[55]+arr[56]+arr[57]+arr[58]+arr[59]+
        arr[60]+arr[61]+arr[62]+arr[63]+arr[64]+arr[65]+arr[66]+arr[67]+arr[68]+arr[69]+
        arr[70]+arr[71]+arr[72]+arr[73]+arr[74]+arr[75]+arr[76]+arr[77]+arr[78]+arr[79]+
        arr[80]+arr[81]+arr[82]+arr[83]+arr[84]+arr[85]+arr[86]+arr[87]+arr[88]+arr[89]+
        arr[90]+arr[91]+arr[92]+arr[93]+arr[94]+arr[95]+arr[96]+arr[97]+arr[98]+arr[99]))
    .add("loop with iterator", () => {
        let res = 0;
        for (const x of arr) res += x;
    })
    .add("traditional for loop", () => {
        let res = 0;
        // cache the length in case the browser can't do it automatically
        const len = arr.length;
        for (let i = 0; i < len; i++) res += arr[i];
    })
    .add("while loop", () => {
        let res = 0;
        let i = arr.length;
        while (i--) res += arr[i];
    })
    .add("loop in a function ", () => sum(arr))
    .on("cycle", (event) => console.log(String(event.target)))
    .run();

In chrome 104, the for-loop-based implementations are the fastest:

jquery               x  1,832,472 ops/sec ±1.35% (61 runs sampled)
lodash               x  2,079,009 ops/sec ±1.11% (68 runs sampled)
forEach              x  4,887,484 ops/sec ±2.35% (67 runs sampled)
reduce               x 21,762,391 ops/sec ±0.46% (69 runs sampled)
predefined reduce    x  2,026,411 ops/sec ±0.50% (68 runs sampled)
eval                 x     33,381 ops/sec ±2.54% (66 runs sampled)
recursion            x  2,252,353 ops/sec ±2.13% (62 runs sampled)
recursion2           x  2,301,516 ops/sec ±1.15% (65 runs sampled)
recursion3           x  2,395,563 ops/sec ±1.65% (66 runs sampled)
naive                x 31,244,240 ops/sec ±0.76% (66 runs sampled)
loop with iterator   x 29,554,762 ops/sec ±1.07% (66 runs sampled)
traditional for loop x 30,052,685 ops/sec ±0.67% (66 runs sampled)
while loop           x 18,624,045 ops/sec ±0.17% (69 runs sampled)
loop in a function   x 29,437,954 ops/sec ±0.54% (66 runs sampled)

Firefox 104 shows similar behaviour:

jquery               x  1,461,578 ops/sec ±1.58% (64 runs sampled)
lodash               x  4,931,619 ops/sec ±0.80% (66 runs sampled)
forEach              x  5,594,013 ops/sec ±0.51% (68 runs sampled)
reduce               x  3,731,232 ops/sec ±0.53% (66 runs sampled)
predefined reduce    x  2,633,652 ops/sec ±0.54% (66 runs sampled)
eval                 x    105,003 ops/sec ±0.88% (66 runs sampled)
recursion            x  1,194,551 ops/sec ±0.24% (67 runs sampled)
recursion2           x  1,186,138 ops/sec ±0.20% (68 runs sampled)
recursion3           x  1,191,921 ops/sec ±0.24% (68 runs sampled)
naive                x 21,610,416 ops/sec ±0.66% (66 runs sampled)
loop with iterator   x 15,311,298 ops/sec ±0.43% (67 runs sampled)
traditional for loop x 15,406,772 ops/sec ±0.59% (67 runs sampled)
while loop           x 11,513,234 ops/sec ±0.60% (67 runs sampled)
loop in a function   x 15,417,944 ops/sec ±0.32% (68 runs sampled)

Discussion

Implementations defining an anonymous function are generally slower because creating an anonymous function is a significant overhead. When running the benchmark with a large array, e.g., with length 1000 instead of 100, the difference between reduce and the for-loop-based implementations becomes insignificant in chrome.

Chrome’s V8 engine knows how to inline simple anonymous functions in reduce since the reduce test case is much faster than the predefined reduce test case. Firefox seems to try something similar but is less efficient in doing so. Non-inlined function calls are pretty slow in js since the call stack is less efficient than the call stack in compiled software.

Similar to reduce, the forEach— and jquery-based implementations use anonymous functions and are relatively slow. lodash has a specialized sum implementation, but it is (as of v4.0.0) implemented as a special case of sumBy, which is relatively inefficient.

eval is the by far slowest test case. This makes sense since constructing the string using concatenations might cause several dynamic allocations (which are slow). Next, the parser has to be invoked and only then can the code be finally executed.

I’ve included some recursive implementations because some people on the internet claim that recursion is faster than loops in js. I can’t reproduce their example — using benchmark.js, recursion is very slow, and when using console.time with a loop, both functions take the same time. When calculating the sum, as expected, recursion is much slower than loops, probably due to intense usage of the js call stack.

The naive implementation would be manually adding all 100 elements of the array. While being quite inconvenient, this is the fastest implementation. But, luckily, for-loops come very close. Adding a single function call around the loop doesn’t harm the performance. Therefore, you can feel free to use the utility function from above.

I have no explanation why the while loop is slower than the for loop. Iterating the array in reverse doesn’t seem to be the problem here.

Источник

Whether you’re using JavaScript, Python, or C++, these programs definitely add up.

Sum of all elements in an array

An array is a collection of elements stored at contiguous memory locations. It’s the most used data structure in programming. In this article, you’ll learn how to find the sum of all elements in an array using C++, Python, and JavaScript.

Problem Statement

You’re given an array of numbers, and you need to calculate and print the sum of all elements in the given array.

Example 1: Let arr = [1, 2, 3, 4, 5]

Therefore, the sum of all elements of the array = 1 + 2 + 3 + 4 + 5 = 15.

Thus, the output is 15.

Example 2: Let arr = [34, 56, 10, -2, 5, 99]

Therefore, the sum of all elements of the array = 34 + 56 + 10 + (-2) + 5 + 99 = 202.

Thus, the output is 202.

Approach to Find the Sum of All Elements in an Array

You can find the sum of all elements in an array by following the approach below:

  1. Initialize a variable sum to store the total sum of all elements of the array.
  2. Traverse the array and add each element of the array with the sum variable.
  3. Finally, return the sum variable.

C++ Program to Find the Sum of All Elements in an Array

Below is the C++ program to find the sum of all elements in an array:

 // C++ program to find the sum of elements in an array
#include <iostream>
using namespace std;
// Function to return the sum of elements in an array
int findSum(int arr[], int size)
{
 int sum = 0;
for(int i=0; i<size; i++)
 {
 sum += arr[i];
 }
return sum;
}
// Function to print the elements of the array
void printArray(int arr[], int size)
{
 for(int i=0; i<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
}
// Driver code
int main()
{
 int arr1[] = {1, 2, 3, 4, 5};
 int size1 = sizeof(arr1) / sizeof(arr1[0]);
 cout << "Array 1:" << endl;
 printArray(arr1, size1);
 cout << "Sum of elements of the array: " << findSum(arr1, size1) << endl;
 int arr2[] = {34, 56, 10, -2, 5, 99};
 int size2 = sizeof(arr2) / sizeof(arr2[0]);
 cout << "Array 2:" << endl;
 printArray(arr2, size2);
 cout << "Sum of elements of the array: " << findSum(arr2, size2) << endl;
 int arr3[] = {-1, 50, -56, 43, 53, 356, -324};
 int size3 = sizeof(arr3) / sizeof(arr3[0]);
 cout << "Array 3:" << endl;
 printArray(arr3, size3);
 cout << "Sum of elements of the array: " << findSum(arr3, size3) << endl;
 return 0;
}

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

C++ Program Using STL to Find the Sum of All Elements in an Array

You can also use C++ STL to find the sum of all elements in an array.

 // C++ program using STL to find the sum of elements in an array
#include <bits/stdc++.h>
using namespace std;
// Function to print the elements of the array
void printArray(int arr[], int size)
{
 for(int i=0; i<size; i++)
 {
 cout << arr[i] << " ";
 }
 cout << endl;
}
// Driver code
int main()
{
 int arr1[] = {1, 2, 3, 4, 5};
 int size1 = sizeof(arr1) / sizeof(arr1[0]);
 cout << "Array 1:" << endl;
 printArray(arr1, size1);
 cout << "Sum of elements of the array: " << accumulate(arr1, arr1 + size1, 0) << endl;
 int arr2[] = {34, 56, 10, -2, 5, 99};
 int size2 = sizeof(arr2) / sizeof(arr2[0]);
 cout << "Array 2:" << endl;
 printArray(arr2, size2);
 cout << "Sum of elements of the array: " << accumulate(arr2, arr2 + size2, 0) << endl;
 int arr3[] = {-1, 50, -56, 43, 53, 356, -324};
 int size3 = sizeof(arr3) / sizeof(arr3[0]);
 cout << "Array 3:" << endl;
 printArray(arr3, size3);
 cout << "Sum of elements of the array: " << accumulate(arr3, arr3 + size3, 0) << endl;
 return 0;
}

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

Python Program to Find the Sum of All Elements in an Array

Below is the Python program to find the sum of all elements in an array:

 # Python program to find the sum of elements in an array
# Function to return the sum of elements in an array
def findSum(arr):
    sum = 0
    for element in arr:
        sum += element
    return sum
# Function to print the elements of the array
def printArray(arr):
    for i in range(len(arr)):
        print(arr[i] , end=' ')
    print()
# Driver Code
arr1 = [1, 2, 3, 4, 5]
print("Array 1:")
printArray(arr1)
print("Sum of elements of the array:",findSum(arr1))
arr2 = [34, 56, 10, -2, 5, 99]
print("Array 2:")
printArray(arr2)
print("Sum of elements of the array:",findSum(arr2))
arr3 = [-1, 50, -56, 43, 53, 356, -324]
print("Array 3:")
printArray(arr3)
print("Sum of elements of the array:",findSum(arr3))

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

Python Program Using Built-in Function to Find the Sum of All Elements in an Array

You can also use Python’s sum() function to find the sum of all elements in an array.

 # Python program to find the sum of elements in an array
# Function to print the elements of the array
def printArray(arr):
    for i in range(len(arr)):
        print(arr[i] , end=' ')
    print()
# Driver Code
arr1 = [1, 2, 3, 4, 5]
print("Array 1:")
printArray(arr1)
print("Sum of elements of the array:",sum(arr1))
arr2 = [34, 56, 10, -2, 5, 99]
print("Array 2:")
printArray(arr2)
print("Sum of elements of the array:",sum(arr2))
arr3 = [-1, 50, -56, 43, 53, 356, -324]
print("Array 3:")
printArray(arr3)
print("Sum of elements of the array:",sum(arr3))

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

JavaScript Program to Find the Sum of All Elements in an Array

Below is the JavaScript program to find the sum of all elements in an array:

 // JavaScript program to find the sum of elements in an array
// Function to return the sum of elements in an array
function findSum(arr, size)
{
 let sum = 0;
for(let i=0; i<size; i++)
 {
 sum += arr[i];
 }
return sum;
}
// Function to print the elements of the array
function printArray(arr, size)
{
 for(let i=0; i<size; i++)
 {
 document.write(arr[i] + " ");
 }
 document.write("
");
}
// Driver code
const arr1 = [1, 2, 3, 4, 5]
size1 = arr1.length;
document.write("Array 1: 
");
printArray(arr1, size1);
document.write("Sum of elements of the array: " + findSum(arr1, size1) + "
");
const arr2 = [34, 56, 10, -2, 5, 99]
size2 = arr2.length;
document.write("Array 2: 
");
printArray(arr2, size2);
document.write("Sum of elements of the array: " + findSum(arr2, size2) + "
");
const arr3 = [-1, 50, -56, 43, 53, 356, -324]
size3 = arr3.length;
document.write("Array 3: 
");
printArray(arr3, size3);
document.write("Sum of elements of the array: " + findSum(arr3, size3) + "
");

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

JavaScript Program Using the reduce() Method to Find the Sum of All Elements in an Array

You can also use JavaScript’s reduce() method to find the sum of all elements in an array.

 // JavaScript program to find the sum of elements in an array
// Function to print the elements of the array
function printArray(arr, size)
{
 for(let i=0; i<size; i++)
 {
 document.write(arr[i] + " ");
 }
 document.write("
");
}
// Driver code
const arr1 = [1, 2, 3, 4, 5]
size1 = arr1.length;
document.write("Array 1: 
");
printArray(arr1, size1);
var sum1 = arr1.reduce(function(a, b) { return a + b; }, 0);
document.write("Sum of elements of the array: " + sum1 + "
");
const arr2 = [34, 56, 10, -2, 5, 99]
size2 = arr2.length;
document.write("Array 2: 
");
printArray(arr2, size2);
var sum2 = arr2.reduce(function(a, b) { return a + b; }, 0);
document.write("Sum of elements of the array: " + sum2 + "
");
const arr3 = [-1, 50, -56, 43, 53, 356, -324]
size3 = arr3.length;
document.write("Array 3: 
");
printArray(arr3, size3);
var sum3 = arr3.reduce(function(a, b) { return a + b; }, 0);
document.write("Sum of elements of the array: " + sum3 + "
");

Output:

 Array 1:
1 2 3 4 5 
Sum of elements of the array: 15
Array 2:
34 56 10 -2 5 99 
Sum of elements of the array: 202
Array 3:
-1 50 -56 43 53 356 -324 
Sum of elements of the array: 121

Want to Learn C++?

C++ is among the most popular programming languages. You can use C++ for basic programming, developing games, developing GUI-based applications, developing database software, developing operating systems, and much more.

If you’re a beginner to C++ or want to revise your C++ concepts, check out some of the top websites and courses to get you started.

Источник

На собеседованиях часто просят написать какой-то простой код. Так компания проверяет, знаете ли вы вообще программирование, и смотрит, как вы работаете с кодом. В новом цикле статей мы разберём популярные вопросы с собеседований и покажем, как их можно решить разными способами.

Задание

У нас есть массив с целыми числами, как с положительными, так и отрицательными. Все числа в массиве разные. Если сложить или вычесть любые два числа из массива, они точно поместятся в стандартной целочисленной переменной.

Ещё у нас есть какое-то целое число — оно не в массиве, а само по себе, отдельной переменной.

Нужно вывести индексы тех двух элементов, которые в сумме дают то самое отдельное число. Например, если в массиве у нас (2, 4, 5, 1, 8), а число — 5, то ответом будет пара 1 и 3, потому что на этих местах стоят числа 4 и 1 (и дают в сумме 5). Помните, что нумерация массивов почти во всех языках программирования начинается с нуля.

Решение простым перебором

Самый простой способ решить эту задачу — перебрать попарно все элементы массива и посмотреть, даст ли какая-то пара нужную сумму. Этот код вряд ли впечатлит работодателя, но результат вы получите верный.

Логика такая:

  1. В первом цикле перебираем все элементы от первого до предпоследнего.
  2. Внутрь вкладываем второй, но делаем это так, чтобы не пересекаться по индексам с первым циклом. Для этого смотрим на переменную, с которой работает первый цикл, и начинаем со следующей — и до последнего элемента.
  3. Внутри второго цикла складываем элементы массива с нашими индексами и смотрим, получился нужный результат или нет.
  4. Если получился — выводим результат и останавливаемся.
  5. Если не получился — идём на новый виток цикла.
  6. Если мы прошли весь массив, но так ничего и не нашли — выводим сообщение о том, что такой пары нет.
# массив с числами
nums = [2, 4, 5, 1, 8]

# сумма
target = 5

# функция, которая найдёт ответ
def twoSum(nums, target):
    # сообщение по умолчанию
    answer = 'В массиве нет такой пары чисел'
    # запускаем первый цикл
    for i in range(len(nums) - 1):
        #  запускаем второй цикл
        for j in range(i + 1, len(nums)):
            # если получили нужный результат —
            if target == nums[i] + nums[j]:
                # меняем ответ и добавляем в него индексы элементов
                answer = 'Ответ: ' + str(i) + ' и ' + str(j)
    # выводим результат работы функции 
    return answer

# запускаем код
print(twoSum(nums, target))

Разбор: задача про массив и сумму чисел

Решение с дополнительным словарём

Если хотите показать, что вы умеете нестандартно мыслить — используйте приём с дополнительным словарём, в котором данные хранятся попарно: ключ и значение. С ним можно убрать один вложенный цикл и сократить количество вычислений. Работает приём так: мы создаём дополнительный словарь, в котором будем хранить результаты просмотра исходного массива. Но создаём его с одной особенностью: мы будем заполнять его не по порядку, а указывая в качестве ключей значения элементов исходного массива. Например, если в исходном массиве у элемента с индексом 2 значение равно 15, то мы в новом словаре создаём элемент с ключом 15 и кладём туда двойку:

Разбор: задача про массив и сумму чисел

Это даст нам быстрый доступ к индексам уже проверенных элементов — мы просто указываем значение элемента и сразу получаем его индекс в исходном массиве. 

Остальная логика выглядит так:

  1. Перебираем исходный массив и на каждом шаге считаем разницу между нужным значением и очередным элементом.
  2. Если разница есть в словаре с просмотренными элементами — выводим оба индекса.
  3. Если разницы в словаре нет — добавляем только что просмотренный элемент в словарь.

Проще говоря, мы перебираем элементы, считаем разницу и смотрим, попадался ли нам результат вычитания среди тех элементов, которые мы уже перебрали. Вот как это выглядит в коде:

# массив с числами
nums = [2, 4, 5, 1, 8]

# сумма
target = 5

# функция, которая найдёт ответ
def twoSum(nums, target):
    # сообщение по умолчанию
    answer = 'В массиве нет такой пары чисел'
    # дополнительный словарь с уже проверенными элементами
    hashmap = {}
    # перебираем исходный массив
    for i in range(len(nums)):
        # находим разницу между нужным значением и очередным элементом
        complement = target - nums[i]
        # если такое значение нам уже попадалось раньше —
        if complement in hashmap:
            # получаем индекс того значения и выводим ответ
            answer = 'Ответ: ' + str(hashmap[complement]) + ' и ' + str(i)
        # если не попадалось — запоминаем индекс по значению элемента
        hashmap[nums[i]] = i
    # выводим результат работы функции 
    return answer

# запускаем код
print(twoSum(nums, target))

Разбор: задача про массив и сумму чисел

Что дальше

Есть ещё третий способ решения этой задачи — попробуйте найти его сами и почувствовать себя на собеседовании. И подпишитесь, чтобы не пропустить новые статьи с разборами.

Вёрстка:

Кирилл Климентьев

Источник

Сегодня мы начнём рассматривать алгоритмы обработки
информации в массивах. Достаточно часто встречается ситуация, при которой нам
необходимо сложить элементы массива, рассмотрим задачу. На складе яблоки
хранятся в мешках, известно количество мешков и количество яблок в каждом
мешке. Директор склада попросил нас написать программу, которая вычисляет
количество яблок на складе.

Обозначим через n количество мешков на складе, через i
– номер текущего мешка, а через s – сумму яблок в мешках. Очевидно, что
для решения данной задачи нам удобно будет представить склад в виде массива
целых чисел a, элементами которого будут мешки с яблоками. Значениями
элементов будут количества яблок в мешках.

Составим блок-схему алгоритма решения задачи.
Блок-схема начинается с блока «Начало», далее будет следовать блок ввода
количества мешков на складе – n.
За ним будет следовать цикл «Для i от 1 до n», в котором будет блок ввода i-того
элемента массива. Далее мы должны задать значение суммы яблок в мешках, равной
нулю, так как пока ни одного мешка мы не просмотрели, s =
0.
Потом снова будет следовать цикл «Для i от 1 до n», внутри
которого будет одна команда – присваивания переменной s сумму её
текущего значения и значения количества яблок в i-том мешке, s = s + a[i].
Таким образом, после просмотра всех n мешков, s будет содержать
сумму яблок во всех мешках. Далее будет следовать блок вывода s, блок-схема всегда заканчивается
блоком «Конец».

Блок-схема
алгоритма решения задачи

Начнём написание программы. Запишем служебное слово program. Назовём нашу программу sklad.
В разделе описания переменных var укажем,
что нам нужен массив a,
так как количество мешков в момент написания программы неизвестно, возьмём
размерность массива равной максимально возможному количеству мешков, например 100 элементов типа integer. А также нам понадобится
переменная n,
в которой будет храниться количество мешков на складе, переменная i,
которая будет хранить индекс текущего элемента массива, и переменная s, которая будет хранить значение
суммы яблок в мешках. Так как в данной задаче все величины выражаются в целых
числах, все переменные будут типа integer.

Между
служебными словами begin и end запишем тело программы.
Для начала выведем на экран поясняющее сообщение о том, что это программа
подсчёта яблок на cкладе
с запросом на ввод количества мешков на складе. Затем запишем команду
считывания значения переменной n с переходом на следующую строку. Далее запишем цикл for i:=1
to
n
do,
который будет содержать команду вывода на экран запроса на ввод количества
яблок в i-том мешке и команду считывания с переходом на следующую строку
значения

i-того элемента массива a.
Таким образом, мы ввели количество яблок в мешках.

Теперь
присвоим переменной s значение 0 и запишем цикл for i:=1
to
n
do,
который будет содержать всего одну команду – присваивание переменной «С», суммы
её текущего значения и значения И-того элемента массива «A»,

s:=
s
+ a[i].
Далее будет следовать команда вывода на экран поясняющего сообщения с текстом
«Количество яблок на складе:», а также значения переменной s.

Программа
решения задачи

Запустим программу на выполнение, пусть на складе
будет 4 мешка яблок, в первом мешке будет 100 яблок, во втором – 200, в третьем
– 300, а в четвёртом – 400. Действительно, всего на складе должна быть тысяча
яблок. Программа работает верно.

Пример
работы программы

Ещё раз рассмотрим нахождение суммы элементов массива
на примере нашей программы. В начале для хранения суммы элементов массива
выделяется ячейка памяти, в нашем случае это переменная s, затем ей присваивается значение,
равное 0, после чего для каждого элемента массива этой переменной присваивается
сумма её значения и значения элемента массива.

Теперь мы знаем, как найти сумму элементов массива.
Рассмотрим ещё одну задачу. Написать программу для нахождения суммы цифр целого
положительного числа. Длина числа до девяти цифр.

Обозначим число, которое вводится – k, количество его цифр – n, номер текущей цифры – i,
сумму цифр – s,
а также нам понадобится массив a, элементами которого будут цифры данного числа.

Для
начала составим блок-схему данного алгоритма. Она будет начинаться с блока
«Начало», за которым будет следовать блок ввода числа k, далее нам нужно
проинициализировать переменную i –
она
будет равна нулю, так как массив цифр a пока не содержит ни одной цифры.

Теперь
нам нужно сделать из числа k
массив цифр. Запишем для этого цикл «Пока» с условием k >
0, который
будет содержать команду выделения последней цифры числа k и записи её в
массив a.
Для этого достаточно использовать функцию нахождения остатка от деления,
которая в языке Pascal
называется mod,
так в начале нам нужно определить, в какой элемент массива a мы будем записывать данную цифру.
Для этого к числу i нужно прибавить единицу.

Теперь
i-тому элементу массива a присвоим значение последней цифры числа k, это будет остаток от его деления на
10. Теперь нужно убрать из числа k его последнюю цифру, для этого
достаточно присвоить числу k результат его безостаточного
деления на 10, данная операция записывается в языке Pascal
словом div.
Таким образом, после выполнения указанного цикла действий в массиве a
будут содержаться цифры числа k,
а в переменной i будет содержаться номер элемента массива a, в который была сохранена старшая по
разряду цифра. Он будет совпадать с количеством цифр в числе, поэтому присвоим
переменной n
значение переменной i. А также присвоим
переменной s
значение 0. Далее будет следовать уже знакомый нам цикл вычисления суммы
элементов массива a.
После него будет блок вывода

s
–
суммы цифр числа. Блок-схема будет заканчиваться
блоком «Конец».

Блок-схема
алгоритма решения задачи

Посмотрим, как работает наш алгоритм на примере числа
345. В начале переменной i присваивается значение 0. Так как 345 больше 0 – i увеличится
на 1, после чего первому элементу массива будет присвоено значение остатка от
деления 345 на 10, то есть 5. Само число k будет без остатка поделено на 10, и
станет равным 34. Далее так как 34 больше 0, значение переменной i
снова
увеличится на 1 и станет равным 2. Так i-тому элементу массива
будет присвоен результат остатка от деления 34 на 10, то есть 4. А число k снова будет поделено без остатка на
10 и станет равным 3. Так как 3 больше 0, переменная i станет равной 3, третьему
элементу массива a
будет присвоено значение 3, а число k снова будет поделено без остатка на
10 и станет равным 0. После завершения работы цикла массив a будет
содержать цифры числа k
в порядке, обратном их следованию в числе, а переменная i
будет
содержать номер элемента массива, который хранит цифру числа k с
самым высоким разрядом, это же число будет равно количеству элементов массива,
поэтому присвоим переменной n
значение i.
Теперь остаётся лишь просуммировать элементы массива. И вывести значение суммы
на экран. Она будет равна 12.

 Приступим к написанию программы. Назовём нашу
программу sum.
Так как число по условию не длиннее 9 цифр и значение цифры может быть только
целым, раздел описания переменных будет содержать массив a из 9 элементов типа integer, а также переменные i,
n,
s
и k
типа integer.
Тело программы будет начинаться с команды вывода на экран поясняющего сообщения
о том, что пользователь работает с программой нахождения суммы цифр числа, и
запрос на ввод числа. Далее будет следовать команда считывания числа k. Теперь присвоим переменной i
значение ноль и запишем цикл преобразования числа k в массив цифр. Он будет
продолжаться, пока k
больше 0 и будет содержать команду увеличения i на 1, команду
присваивания i-тому элементу массива a значения остатка от деления k на 10 и команду присваивания
переменной k
её значения, поделённого без остатка на 10.

После окончания цикла присвоим переменной n значение переменной i,
а переменной s
– ноль. После чего запишем цикл for i:=1
to
n
do,
который будет содержать команду присваивания переменной s суммы её текущего значения и
значения i-того
элемента массива a.
Далее будет следовать команда вывода на экран поясняющего сообщения «Сумма цифр
числа:», а также значения переменной s.

Исходный
код программы

Запустим программу на выполнение. Введём число 34 964.
Получим ответ. Сумма цифр данного числа будет равна 26. Программа работает
правильно, следовательно, задача решена.

Пример
работы программы

Обратим внимание, что данную задачу можно решать и без
использования массива. Для этого достаточно присвоить переменной s значение 0 в начале программы, и при
выделении каждой цифры числа сразу добавлять её значение к s.

Изменим нашу программу. Уберём из неё цикл нахождения
суммы элементов массива, команду присваивания переменной s значения 0 перенесём сразу после
ввода числа, а также изменим цикл выделения цифр числа. Теперь можно убрать из
раздела описания переменных переменные i и n, а также массив a.

Изменённая
программа

Из-за того, что изменённая программа имеет в своём
составе меньшее количество команд и использует меньшее количество переменных,
то есть потребляет меньше оперативной памяти, она будет работать быстрее. Снова
запустим программу на выполнение и введём то же число, что и в первый раз, 34
964. Как и в первый раз, программа вывела ответ 26. Программа работает верно.

Пример
работы изменённой программы

Важно запомнить:

Алгоритм
нахождения суммы элементов массива состоит из трёх шагов:

1)     
Выделения ячейки памяти для хранения
суммы.

2)     
Присваивания ей значения 0.

3)      Перебора элементов массива с вычислением для каждого суммы
его значения и значения ячейки памяти для хранения суммы и с присваиванием
результата ячейке памяти для хранения суммы.

Мы научились применять алгоритм нахождения суммы
элементов массива при решении задач.

Источник

В этом посте мы обсудим, как найти сумму элементов в массиве C++.

1. Использование STL accumulate() функция

Стандартным решением является использование std::accumulate предоставляется стандартной библиотекой. Он определен в заголовочном файле numeric. Операция по умолчанию заключается в добавлении элементов до но, чтобы сделать контекст более понятным. Мы также можем передать функцию в необязательном четвертом параметре, которая выполняет операцию сложения двух чисел и возвращает результат.

#include <iostream>

#include <numeric>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2 };

    int sum = std::accumulate(std::begin(arr), std::end(arr), 0, std::plus<int>());

    std::cout << sum;

    return 0;

}

Скачать  Выполнить код

2. Использование Boost accumulate() функция

Еще одна хорошая альтернатива — использовать boost accumulate() функция, которая определена в заголовочном файле boost/range/numeric.hpp.

#include <iostream>

#include <boost/range/numeric.hpp>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2 };

    int sum = boost::accumulate(arr, 0);

    std::cout << sum;

    return 0;

}

Скачать код

3. Использование STL for_each() функция

Мы также можем написать логику суммирования в предикате для std::for_each стандартный алгоритм. Это показано ниже с использованием лямбда-выражений:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

#include <iostream>

#include <algorithm>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2 };

    int sum = 0;

    std::for_each(std::begin(arr), std::end(arr),

                [&] (int &i) {

                    sum += i;

                });

    std::cout << sum;

    return 0;

}

Скачать  Выполнить код

4. Цикл for/цикл for на основе диапазона

Мы также можем написать собственную процедуру для этой простой задачи. Идея состоит в том, чтобы пройти массив, используя простой цикл for или цикл for на основе диапазона, и накопить сумму каждого элемента в переменной.

⮚ Для цикла

#include <iostream>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2};

    int n = sizeof(arr) / sizeof(int);

    int sum = 0;

    for (int i = 0; i < n; i++) {

        sum += arr[i];

    }

    std::cout << sum;

    return 0;

}

Скачать  Выполнить код

⮚ Цикл for на основе диапазона

#include <iostream>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2 };

    int sum = 0;

    for (int i: arr) {

        sum += i;

    }

    std::cout << sum;

    return 0;

}

Скачать  Выполнить код

5. Использование valarray sum() функция

Если valarray используется вместо стандартного массива, операция суммирования может быть применена непосредственно к valarray объект, вызвав его функцию-член sum().

#include <iostream>

#include <valarray>

int main()

{

    int arr[] = { 5, 3, 7, 9, 2 };

    int n = sizeof(arr) / sizeof(int);

    std::valarray<int> valarray (arr, n);

    std::cout << valarray.sum();

    return 0;

}

Скачать  Выполнить код

6. C++17 — Свернуть выражения

С C++17 мы можем использовать складывать выражения, как показано ниже:

#include <iostream>

template<typename ...T>

auto sum(T ...args) {

    return (args + ...);

}

int main()

{

    std::cout << sum( 5, 3, 7, 9, 2 );

    return 0;

}

Выполнить код

Это все, что касается нахождения суммы элементов в массиве C++.

Источник

Понравилась статья? Поделить с друзьями:
  • Как найти архив предприятия для оформления пенсии
  • Как найти массовую долю вещества в воде
  • Как соколов нашел сына
  • Как найти профиль инстаграмма по фото
  • Как найти по иду в авито