Operações Comuns com Arrays

Parte da seção Fundamentos do Journey de C++ da Coddy — lição 66 de 74.

Aqui estão algumas operações comuns de array:

Encontre a soma de todos os elementos em um array:

int numbers[] = {1, 2, 3, 4, 5};
int sum = 0;
for (int number : numbers) {
    sum += number;
}
std::cout << "Sum: " << sum;

Encontre a média dos elementos em um array:

int numbers[] = {1, 2, 3, 4, 5};
double sum = 0;
for (int number : numbers) {
    sum += number;
}
double average = sum / std::size(numbers);
std::cout << "Average: " << average;

Encontre o elemento máximo em um array:

int numbers[] = {1, 5, 2, 9, 3};
int max = numbers[0];
for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}
std::cout << "Max: " << max;

Encontre o mínimo elemento em um array:

int numbers[] = {1, 5, 2, 9, 3};
int min = numbers[0];
for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] < min) {
        min = numbers[i];
    }
}
std::cout << "Min: " << min;

Desafio

Fácil

Crie uma função chamada calculateStats que recebe um array de doubles e o tamanho do array como entrada e realiza as seguintes operações:

Calcula a soma de todos os elementos no array.
Calcula a média dos elementos no array.
Encontra o elemento máximo no array.
Encontra o elemento mínimo no array.

A função deve retornar um array de doubles contendo a soma, a média, o máximo e o mínimo, nessa ordem.

Notas importantes:

Use o parâmetro size para controlar seu loop — não use std::size().
Para inicializar max e min, comece-os em arr[0] — isso funciona corretamente mesmo quando o array contém apenas números negativos.
O código pré-escrito em main() já aloca um array dinâmico usando new e o libera com delete[] — você só precisa alocar o array de resultado dentro da sua função usando new double[4] e retorná-lo.

Abordagem sugerida:

Inicialize sum = 0, max = arr[0] e min = arr[0].
Faça um loop de i = 0 até i < size, acumulando a soma e atualizando max/min conforme necessário.
Calcule a média como sum / size.
Aloque um novo array com new double[4], armazene os quatro resultados em ordem e retorne-o.

Folha de consulta

Operações comuns com arrays em C++:

Soma de todos os elementos:

int numbers[] = {1, 2, 3, 4, 5};
int sum = 0;
for (int number : numbers) {
    sum += number;
}

Média dos elementos:

int numbers[] = {1, 2, 3, 4, 5};
double sum = 0;
for (int number : numbers) {
    sum += number;
}
double average = sum / std::size(numbers);

Elemento máximo:

int numbers[] = {1, 5, 2, 9, 3};
int max = numbers[0];
for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] > max) {
        max = numbers[i];
    }
}

Elemento mínimo:

int numbers[] = {1, 5, 2, 9, 3};
int min = numbers[0];
for (int i = 1; i < std::size(numbers); i++) {
    if (numbers[i] < min) {
        min = numbers[i];
    }
}

Experimente você mesmo

#include <iostream>

double* calculateStats(double arr[], int size) {
    // Você precisará calcular 4 valores antes de armazená-los em newArr
    // Inicialize variáveis para sum (comece em 0), max e min (ambos começam em arr[0])
    // Use um loop for para iterar através do array
    // Dentro do loop:
    //   - Adicione cada elemento a sum
    //   - Compare cada elemento com max e atualize se for maior
    //   - Compare cada elemento com min e atualize se for menor
    // Calcule average = sum / size (após o loop)
    

    double* newArr = new double[4];
    newArr[0] = sum;
    newArr[1] = average;
    newArr[2] = max;
    newArr[3] = min;

    return newArr;
}

int main() {
    int n;

    std::cin >> n;
    std::cin.ignore();
    double arr[n];

    for (int i = 0; i < n; i++) {
        double val;
        std::cin >> val;
        arr[i] = val;
    }

    double* stats = calculateStats(arr, n);
    std::cout << "Sum: " << stats[0] << std::endl;
    std::cout << "Average: " << stats[1] << std::endl;
    std::cout << "Maximum: " << stats[2] << std::endl;
    std::cout << "Minimum: " << stats[3] << std::endl;
    delete[] stats;
    return 0;
}