Произведение элементов массива — итеративно и рекурсивно

Экран ноутбука с кодом на C++, Python, JavaScript и C

Кратко: покажу, как найти произведение всех элементов массива двумя способами — циклом и рекурсией. Приведены примеры на C++, Python, JavaScript и C. Объясняю сложность, крайние случаи и даю готовые сниппеты и критерии тестирования.

Задача

Дан массив arr. Нужно вычислить произведение всех его элементов и вывести итог. Решение реализуйте итеративно (с помощью циклов) и рекурсивно.

Примеры

Пример 1: arr = [1, 2, 3, 4, 5, 6, 7, 8] Произведение = 1 2 3 4 5 6 7 * 8 = 40320
Пример 2: arr = [1, 1, 1, 1, 1, 1] Произведение = 1

Итеративный подход

Идея простая:

Завести переменную result = 1.
Пройти по всем элементам массива и умножать result на текущий элемент.
Вернуть результат.

Важно: при работе с целыми числами следите за переполнением. Если в массиве есть ноль, результат будет 0 и дальнейшие вычисления не изменят итог — можно прервать цикл заранее.

Программа на C++ (циклы)

// C++ program to find the product of the array elements  
#include   
using namespace std;  
  
int findProduct(int arr[], int size)  
{  
 int result = 1;  
 for(int i=0; i

Вывод этого примера:

Array 1:  
1 2 3 4 5 6 7 8   
Product of the array elements: 40320  
Array 2:  
1 1 1 1 1 1   
Product of the array elements: 1

`Python (циклы)`

# Python program to find product of the list elements  
  
def findProduct(arr, size):  
    result = 1  
    for i in range(size):  
        result = result * arr[i]  
    return result  
  
def printListElements(arr, size):  
    for i in range(size):  
        print(arr[i], end=" ")  
    print()  
  
arr1 = [1, 2, 3, 4, 5, 6, 7, 8]  
size1 = len(arr1)  
print("Array 1:")  
printListElements(arr1, size1)  
print("Product of the array elements:", findProduct(arr1, size1))  
  
arr2 = [1, 1, 1, 1, 1, 1]  
size2 = len(arr2)  
print("Array 2:")  
printListElements(arr2, size2)  
print("Product of the array elements:", findProduct(arr2, size2))

Вывод будет как в примерах выше.

`JavaScript (циклы)`

// JavaScript program to find the product of the array elements  
  
function findProduct(arr, size) {  
 let result = 1;  
 for(let i=0; i

`C (циклы)`

// C program to find the product of the array elements  
#include   
  
int findProduct(int arr[], int size)  
{  
 int result = 1;  
 for(int i=0; i

`Рекурсивный подход`

Псевдокод:

function findProduct(arr,n):  
    if n == 0:  
        return(arr[n])  
    else:  
        return (arr[n] * findProduct(arr, n - 1))

Идея: умножать последний элемент на произведение всех предыдущих, спускаться по индексу до 0.

Замечание: для очень длинных массивов рекурсия может привести к переполнению стека. В таких случаях используйте итеративный вариант.

`Программа на C++ (рекурсия)`

// C++ program to find the product of the array elements using recursion  
#include   
using namespace std;  
  
int findProduct(int arr[], int n)  
{  
 if (n == 0)  
 {  
 return(arr[n]);  
 }  
 else  
 {  
 return (arr[n] * findProduct(arr, n - 1));  
 }  
}  
  
  
void printArrayElements(int arr[], int size)  
{  
 for(int i=0; i

(Аналогичные примеры на Python, JavaScript и C приведены ниже в исходном виде.)

`Практические замечания и крайние случаи`

Пустой массив: не определено стандартное произведение. Решение — заранее определить поведение: возвращать 1 (нейтральный элемент умножения) или бросать ошибку/исключение.
Наличие нуля: результат равен 0; можно оптимизировать, прервав цикл при обнаружении нуля.
Переполнение целочисленного типа: для больших значений результат может выйти за пределы диапазона типа. Используйте больший тип (long long, BigInt, библиотеки для произвольно точной арифметики) или проверку переполнения.
Рекурсивный вариант: для очень длинных массивов возможен StackOverflow. Итерация безопаснее по глубине вызовов.

`Сложность (факт-бокс)`

Время: O(n) — нужно один проход по массиву.
Память: O(1) дополнительной памяти для итеративного варианта; рекурсивный вариант использует O(n) по стеку.

`Альтернативные подходы и сниппеты (шпаргалка)`

Python (короткий вариант): math.prod

import math
math.prod(arr)

JavaScript (короткий): reduce

arr.reduce((a, b) => a * b, 1)

C++ (стандартная библиотека): std::accumulate

#include 
#include 
int product = std::accumulate(arr, arr+size, 1, std::multiplies());

Эти варианты компактнее и выразительнее, но следите за переполнением типов.

`Критерии приёмки (тесты)`

Вход: [1,2,3,4] → ожидаемый результат 24
Вход: [0,5,10] → ожидаемый результат 0 (раннее завершение допустимо)
Вход: [1,1,1,1] → ожидаемый результат 1
Вход: [] → явно задать поведение (1 или ошибка) и протестировать
Вход: очень большой набор значений → проверить на переполнение или корректную обработку типов

`План действий при ошибках`

Если результат странно мал или отрицателен — проверьте переполнение и знаковые типы.
Если рекурсивная реализация падает на больших входах — переключитесь на итеративную или используйте оптимизацию хвостовой рекурсии (если компилятор/язык поддерживает).

`Краткое резюме`

Для задачи “произведение элементов массива” итеративный способ прост и надёжен: O(n) по времени и O(1) по дополнительной памяти.
Рекурсия делает код компактнее, но может привести к переполнению стека.
Следите за нулём в массиве и за переполнением типов; при необходимости используйте расширенные типы или библиотеки для длинной арифметики.

Важно: перед использованием в продакшене определите, как вы обрабатываете пустые массивы и ситуации с переполнением.