STL-Algorithmen

Teil des Abschnitts Objektorientierte Programmierung der C++-Journey von Coddy. Lektion 73 von 104.

STL-Algorithmen sind Template-Funktionen, die auf Bereichen operieren, die durch Iteratoren definiert sind. Sie sind in den Headern <algorithm> und <numeric> zu finden und funktionieren mit jedem Container, der kompatible Iteratoren bereitstellt.

std::sort ordnet Elemente standardmäßig in aufsteigender Reihenfolge an:

#include <algorithm>
#include <vector>

std::vector<int> nums = {5, 2, 8, 1};
std::sort(nums.begin(), nums.end());
// nums: {1, 2, 5, 8}

std::find sucht nach einem Wert und gibt einen Iterator auf die erste Übereinstimmung zurück, oder end(), falls dieser nicht gefunden wurde:

auto it = std::find(nums.begin(), nums.end(), 5);
if (it != nums.end()) {
    std::cout << "Found at index: " << (it - nums.begin());
}

std::transform wendet eine Operation auf jedes Element an und speichert die Ergebnisse in einem Zielbereich:

std::vector<int> doubled(nums.size());
std::transform(nums.begin(), nums.end(), doubled.begin(),
               [](int x) { return x * 2; });
// doubled: {2, 4, 10, 16}

std::accumulate aus <numeric> kombiniert alle Elemente zu einem einzigen Wert:

#include <numeric>

int sum = std::accumulate(nums.begin(), nums.end(), 0);
// sum: 16 (1 + 2 + 5 + 8)

Diese Algorithmen akzeptieren Iterator-Bereiche anstatt Container direkt, was sie flexibel genug macht, um mit Teilbereichen oder verschiedenen Container-Typen mit demselben Code zu arbeiten.

Aufgabe

Einfach

Erstelle einen Score-Analysator, der mithilfe von STL-Algorithmen eine Sammlung von Zahlen verarbeitet. Du erstellst Hilfsfunktionen, die zeigen, wie sort, find, transform und accumulate zusammenarbeiten, um Daten zu analysieren.

Du organisierst deinen Code über zwei Dateien:

ScoreAnalyzer.h: Definiere Hilfsfunktionen, die STL-Algorithmen verwenden, um Vektoren von Ganzzahlen zu verarbeiten.
Erstelle eine Funktion namens sortScores, die einen std::vector<int>& entgegennimmt und ihn mithilfe von std::sort in aufsteigender Reihenfolge sortiert.

Erstelle eine Funktion namens findScore, die einen const std::vector<int>& und einen Zielwert vom Typ int entgegennimmt. Verwende std::find, um nach dem Zielwert zu suchen. Wenn er gefunden wird, gib den Index zurück (den Abstand vom Anfang). Wenn er nicht gefunden wird, gib -1 zurück.

Erstelle eine Funktion namens applyBonus, die einen const std::vector<int>& und einen Bonusbetrag vom Typ int entgegennimmt. Verwende std::transform, um einen neuen Vektor zu erstellen und zurückzugeben, in dem jeder Punktestand um den Bonus erhöht wurde.

Erstelle eine Funktion namens calculateAverage, die einen const std::vector<int>& entgegennimmt und den Durchschnitt als double zurückgibt. Verwende std::accumulate, um die Summe zu berechnen, und teile sie anschließend durch die Größe.

Erstelle eine Funktion namens printVector, die einen const std::vector<int>& entgegennimmt und alle Elemente durch Leerzeichen getrennt ausgibt, gefolgt von einem Zeilenumbruch.
main.cpp: Lies sechs Eingaben ein (jede in einer eigenen Zeile):
1. Erster Punktestand (Ganzzahl)
2. Zweiter Punktestand (Ganzzahl)
3. Dritter Punktestand (Ganzzahl)
4. Vierter Punktestand (Ganzzahl)
5. Ein zu suchender Punktestand (Ganzzahl)
6. Ein anzuwendender Bonusbetrag (Ganzzahl)
Erstelle einen Vektor mit den vier Punkteständen und führe die Algorithmen vor:
1. Gib Original: aus, gefolgt von den Inhalten des Vektors
2. Sortiere die Punktestände und gib Sorted: aus, gefolgt vom sortierten Vektor
3. Suche im sortierten Vektor nach dem Zielpunktestand. Wenn er gefunden wird, gib Found <value> at index <index> aus. Wenn er nicht gefunden wird, gib <value> not found aus
4. Wende den Bonus auf die sortierten Punktestände an und gib With bonus: aus, gefolgt vom neuen Vektor
5. Berechne den Durchschnitt der ursprünglichen sortierten Punktestände (vor dem Bonus) und gib ihn als Average: <value> mit einer Nachkommastelle aus

Zum Beispiel mit den Eingaben 75, 90, 60, 85, 85 und 5:

Original: 75 90 60 85 
Sorted: 60 75 85 90 
Found 85 at index 2
With bonus: 65 80 90 95 
Average: 77.5

Mit den Eingaben 100, 80, 95, 70, 50 und 10:

Original: 100 80 95 70 
Sorted: 70 80 95 100 
50 not found
With bonus: 80 90 105 110 
Average: 86.2

Denke daran, <algorithm> für sort, find und transform sowie <numeric> für accumulate einzubinden. Verwende std::fixed und std::setprecision(1) aus <iomanip>, um den Durchschnitt zu formatieren.

Probier es selbst

#include <iostream>
#include <vector>
#include <iomanip>
#include "ScoreAnalyzer.h"

using namespace std;

int main() {
    // Sechs Eingaben lesen
    int score1, score2, score3, score4;
    int searchTarget, bonusAmount;
    
    cin >> score1;
    cin >> score2;
    cin >> score3;
    cin >> score4;
    cin >> searchTarget;
    cin >> bonusAmount;
    
    // TODO: Erstelle einen vector mit den vier Punktzahlen
    
    // TODO: Gib "Original:" gefolgt vom Inhalt des vector aus
    
    // TODO: Sortiere die Punktzahlen und gib "Sorted:" gefolgt vom sortierten vector aus
    
    // TODO: Suche nach der Zielpunktzahl im sortierten vector
    // Falls gefunden, gib "Found <value> at index <index>" aus
    // Falls nicht gefunden, gib "<value> not found" aus
    
    // TODO: Wende den Bonus auf die sortierten Punktzahlen an und gib "With bonus:" gefolgt vom neuen vector aus
    
    // TODO: Berechne und gib den Durchschnitt der sortierten Punktzahlen (vor dem Bonus) aus
    // Verwende fixed und setprecision(1) für die Formatierung
    // Gib als "Average: <value>" aus
    
    return 0;
}