Gängige Array-Operationen

Teil des Abschnitts Grundlagen der C++-Journey von Coddy — Lektion 66 von 74.

Hier sind einige gängige Array-Operationen:

Finde die Summe aller Elemente in einem Array:

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

Finden Sie den Durchschnitt der Elemente in einem 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;

Finde das maximale Element in einem 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;

Finde das kleinste Element in einem 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;

Aufgabe

Einfach

Erstellen Sie eine Funktion namens calculateStats, die ein Array von Doubles und die Größe des Arrays als Eingabe entgegennimmt und die folgenden Operationen ausführt:

Berechnet die Summe aller Elemente im Array.
Berechnet den Durchschnitt der Elemente im Array.
Findet das maximale Element im Array.
Findet das minimale Element im Array.

Die Funktion sollte ein Array von Doubles zurückgeben, das die Summe, den Durchschnitt, das Maximum und das Minimum in dieser Reihenfolge enthält.

Wichtige Hinweise:

Verwenden Sie den Parameter size, um Ihre Schleife zu steuern — verwenden Sie nicht std::size().
Um max und min zu initialisieren, setzen Sie diese auf arr[0] — dies funktioniert auch dann korrekt, wenn das Array nur negative Zahlen enthält.
Der bereits geschriebene Code in main() reserviert bereits ein dynamisches Array mit new und gibt es mit delete[] wieder frei — Sie müssen lediglich das Ergebnis-Array innerhalb Ihrer Funktion mit new double[4] reservieren und zurückgeben.

Empfohlene Vorgehensweise:

Initialisieren Sie sum = 0, max = arr[0] und min = arr[0].
Laufen Sie in einer Schleife von i = 0 bis i < size, wobei Sie die Summe akkumulieren und max/min nach Bedarf aktualisieren.
Berechnen Sie den Durchschnitt als sum / size.
Reservieren Sie ein neues Array mit new double[4], speichern Sie die vier Ergebnisse in der richtigen Reihenfolge und geben Sie es zurück.

Spickzettel

Häufige Array-Operationen in C++:

Summe aller Elemente:

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

Durchschnitt der Elemente:

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

Maximales Element:

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];
    }
}

Minimales Element:

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];
    }
}

Probier es selbst

#include <iostream>

double* calculateStats(double arr[], int size) {
    // Sie müssen 4 Werte berechnen, bevor Sie diese in newArr speichern
    // Initialisieren Sie Variablen für Summe (startet bei 0), Max und Min (beide starten bei arr[0])
    // Verwenden Sie eine for-Schleife, um das Array zu durchlaufen
    // Innerhalb der Schleife:
    //   - Addieren Sie jedes Element zur Summe
    //   - Vergleichen Sie jedes Element mit Max und aktualisieren Sie es, falls es größer ist
    //   - Vergleichen Sie jedes Element mit Min und aktualisieren Sie es, falls es kleiner ist
    // Berechnen Sie den Durchschnitt = Summe / Größe (nach der Schleife)
    

    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;
}