Ниже — простая и надёжная программа «суммы элементов одномерного массива»: сначала идея, затем рабочие примеры на популярных языках.

Идея алгоритма

1. Завести аккумулятор sum, изначально 0.

2. Последовательно добавить к нему каждый элемент массива.

3. Вернуть/вывести sum.

Сложность: O(n) по времени и O(1) по памяти.
Для целых лучше использовать «широкий» тип (например, 64-битный), чтобы снизить риск переполнения. Для чисел с плавающей точкой можно при необходимости применить суммирование с компенсацией (Кэхана) для лучшей точности.

Псевдокод

bash
Копировать код
sum ← 0
для i от 0 до n-1:
    sum ← sum + a[i]
вывести sum

Примеры

C (целые, 64-битная сумма)

c
Копировать код
#include 
#include 
int main(void) {
    int n;
    if (scanf("%d", &n) != 1 || n < 0) return 0;
    long long sum = 0; // 64-битная сумма
    for (int i = 0; i < n; ++i) {
        long long x;
        scanf("%lld", &x);
        sum += x;
    }
    printf("%lld\n", sum);
    return 0;
}

C++ (через диапазонный цикл)

cpp
Копировать код
#include 
using namespace std;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n; 
    if (!(cin >> n) || n < 0) return 0;
    long long sum = 0;
    for (int i = 0; i < n; ++i) {
        long long x; 
        cin >> x;
        sum += x;
    }
    cout << sum << "\n";
    return 0;
}

Python (встроенная sum)

python
Копировать код
# Ввод: n, затем n чисел через пробел/перенос строки
n = int(input())
arr = list(map(int, input().split())) if n else []
# Если числа идут на нескольких строках:
while len(arr) < n:
    arr += list(map(int, input().split()))
print(sum(arr))

Python (вещественные + суммирование Кэхана)

python
Копировать код
n = int(input())
vals = []
while len(vals) < n:
    vals += map(float, input().split())
total = 0.0
c = 0.0          # компенсация ошибки
for x in vals:
    y = x - c
    t = total + y
    c = (t - total) - y
    total = t
print(total)

Java

java
Копировать код
import java.io.*;
import java.util.*;
public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int n = fs.nextInt();
        long sum = 0L;
        for (int i = 0; i < n; i++) {
            sum += fs.nextLong();
        }
        System.out.println(sum);
    }
    // Простой быстрый сканер
    static class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr = 0, len = 0;
        FastScanner(InputStream is) { in = is; }
        private int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        long nextLong() throws IOException {
            int c; do c = read(); while (c <= ' '); // пропуск пробелов
            int sgn = 1; if (c == '-') { sgn = -1; c = read(); }
            long x = 0;
            while (c > ' ') { x = x * 10 + (c - '0'); c = read(); }
            return x * sgn;
        }
        int nextInt() throws IOException { return (int) nextLong(); }
    }
}

C# (.NET)

csharp
Копировать код
using System;
using System.Linq;
class Program {
    static void Main() {
        int n = int.Parse(Console.ReadLine() ?? "0");
        long sum = 0;
        while (n > 0) {
            var parts = (Console.ReadLine() ?? "").Split(new[]{' ','\t'}, StringSplitOptions.RemoveEmptyEntries);
            foreach (var p in parts) {
                if (n == 0) break;
                sum += long.Parse(p);
                n--;
            }
        }
        Console.WriteLine(sum);
    }
}

JavaScript (Node.js, чтение из stdin)

javascript
Копировать код
// Ввод: n и затем n чисел через пробелы/переносы
const fs = require('fs');
const data = fs.readFileSync(0, 'utf8').trim().split(/\s+/);
let idx = 0;
const n = Number(data[idx++]);
let sum = 0n; // BigInt для безопасной суммы больших целых
for (let i = 0; i < n; i++) {
  sum += BigInt(data[idx++]);
}
console.log(sum.toString());

Частые нюансы

• Пустой массив: по соглашению сумма равна 0.

• Переполнение: при сумме целых используйте 64-битные типы (long long, long, BigInt), если вход может быть большим.

• Вещественные: порядок сложения влияет на точность; для критичных задач используйте схему Кэхана.

• Проверка ввода: в учебных задачах часто предполагается корректный ввод, но в продакшене валидируйте размер и формат.