Сумма элементов массива

Решение

Понимание задачи

Нужно найти сумму всех элементов массива без использования встроенной функции sum(). Это базовая операция, но важная для тестирования и разработки.

Основное решение: Итерация с циклом

def array_sum(arr):
    """
    Находит сумму всех элементов массива без sum().
    """
    total = 0
    for num in arr:
        total += num
    return total

# Использование
result = array_sum([1, 2, 3, 4, 5])
print(result)  # 15

Как это работает

Пошаговое выполнение:

Шаг 0: total = 0
Шаг 1: total = 0 + 1 = 1
Шаг 2: total = 1 + 2 = 3
Шаг 3: total = 3 + 3 = 6
Шаг 4: total = 6 + 4 = 10
Шаг 5: total = 10 + 5 = 15
Результат: 15

Анализ сложности

Временная сложность: O(n)

• n = количество элементов массива
• Проходим массив один раз
• Каждая итерация выполняет O(1) операцию

Пространственная сложность: O(1)

• Используем только одну переменную total
• Не зависит от размера входного массива

Расширенная реализация с типизацией

from typing import List, Union

def array_sum(arr: List[Union[int, float]]) -> Union[int, float]:
    """
    Находит сумму всех элементов массива.
    
    Args:
        arr: Массив целых или вещественных чисел
    
    Returns:
        Сумма всех элементов
    
    Raises:
        ValueError: Если массив содержит неподдерживаемые типы
    """
    if not isinstance(arr, (list, tuple)):
        raise TypeError("Вход должен быть списком или кортежем")
    
    total = 0
    for num in arr:
        if not isinstance(num, (int, float)):
            raise ValueError(f"Неподдерживаемый тип: {type(num)}")
        total += num
    
    return total

# Тестирование
print(array_sum([1, 2, 3, 4, 5]))  # 15
print(array_sum([1.5, 2.5, 3.0]))  # 7.0
print(array_sum([]))  # 0
print(array_sum([-1, -2, 3]))  # 0

Альтернативные подходы

Способ 1: Функциональный (reduce)

from functools import reduce

def array_sum_reduce(arr):
    return reduce(lambda a, b: a + b, arr, 0)

• Более функциональный стиль
• O(n) время, O(1) дополнительная память
• Менее читаемо для новичков

Способ 2: Рекурсия

def array_sum_recursive(arr):
    if len(arr) == 0:
        return 0
    return arr[0] + array_sum_recursive(arr[1:])

• Рекурсивное решение
• O(n) время, O(n) память (стек вызовов)
• Неэффективно для больших массивов

Способ 3: While цикл

def array_sum_while(arr):
    total = 0
    i = 0
    while i < len(arr):
        total += arr[i]
        i += 1
    return total

• Старомодный стиль
• O(n) время, O(1) память
• Менее Pythonic, чем for цикл

Способ 4: Enumerate для отслеживания индекса

def array_sum_enumerate(arr):
    total = 0
    for index, value in enumerate(arr):
        total += value
    return total

• Полезно, если нужен индекс
• O(n) время, O(1) память

Расширенные варианты

С обработкой пустого массива

def array_sum_safe(arr):
    if not arr:
        return 0
    total = 0
    for num in arr:
        total += num
    return total

С фильтрацией (только положительные)

def array_sum_positive(arr):
    total = 0
    for num in arr:
        if num > 0:
            total += num
    return total

С отладкой (логирование)

def array_sum_debug(arr):
    total = 0
    for i, num in enumerate(arr):
        total += num
        print(f"Шаг {i}: добавлено {num}, итого = {total}")
    return total

Полное тестирование

import pytest

def test_array_sum():
    # Базовые случаи
    assert array_sum([1, 2, 3, 4, 5]) == 15
    assert array_sum([0]) == 0
    assert array_sum([]) == 0
    
    # Отрицательные числа
    assert array_sum([-1, -2, -3]) == -6
    assert array_sum([-5, 5]) == 0
    
    # Вещественные числа
    assert array_sum([1.5, 2.5]) == 4.0
    assert array_sum([0.1, 0.2, 0.7]) == pytest.approx(1.0)
    
    # Большие массивы
    assert array_sum(list(range(1, 101))) == 5050

Выводы

• Базовое решение: for цикл — просто, читаемо, эффективно
• O(n) время, O(1) память — оптимальная сложность
• Граничные случаи: пустой массив, отрицательные числа, вещественные числа
• Для QA: проверить поведение на edge cases, большие значения, переполнение
• Лучшие практики: типизация, обработка ошибок, логирование