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

Lassen Sie uns einen Score-Analyzer erstellen, der eine Sammlung von Zahlen mithilfe von STL-Algorithmen verarbeitet. Sie werden Hilfsfunktionen erstellen, die demonstrieren, wie sort, find, transform und accumulate zusammenarbeiten, um Daten zu analysieren.

Sie werden Ihren Code auf zwei Dateien verteilen:

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

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

Erstellen Sie eine Funktion namens applyBonus, die einen const std::vector<int>& und einen int-Bonusbetrag entgegennimmt. Verwenden Sie std::transform, um einen neuen Vektor zu erstellen und zurückzugeben, bei dem zu jedem Score der Bonus addiert wurde.

Erstellen Sie eine Funktion namens calculateAverage, die einen const std::vector<int>& entgegennimmt und den Durchschnitt als double zurückgibt. Verwenden Sie std::accumulate, um die Summe zu berechnen, und teilen Sie diese dann durch die Größe.

Erstellen Sie eine Funktion namens printVector, die einen const std::vector<int>& entgegennimmt und alle Elemente durch Leerzeichen getrennt ausgibt, gefolgt von einem Zeilenumbruch.
main.cpp: Lesen Sie sechs Eingaben ein (jede in einer separaten Zeile):
1. Erster Score (Ganzzahl)
2. Zweiter Score (Ganzzahl)
3. Dritter Score (Ganzzahl)
4. Vierter Score (Ganzzahl)
5. Ein Score, nach dem gesucht werden soll (Ganzzahl)
6. Ein anzuwendender Bonusbetrag (Ganzzahl)
Erstellen Sie einen Vektor mit den vier Scores und demonstrieren Sie die Algorithmen:
1. Geben Sie Original: gefolgt vom Inhalt des Vektors aus
2. Sortieren Sie die Scores und geben Sie Sorted: gefolgt vom sortierten Vektor aus
3. Suchen Sie nach dem Ziel-Score im sortierten Vektor. Wenn er gefunden wird, geben Sie Found <value> at index <index> aus. Wenn er nicht gefunden wird, geben Sie <value> not found aus
4. Wenden Sie den Bonus auf die sortierten Scores an und geben Sie With bonus: gefolgt vom neuen Vektor aus
5. Berechnen und geben Sie den Durchschnitt der ursprünglichen sortierten Scores (vor dem Bonus) 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

Denken Sie daran, <algorithm> für sort, find und transform sowie <numeric> für accumulate einzubinden. Verwenden Sie std::fixed und std::setprecision(1) aus <iomanip> für die Formatierung des Durchschnitts.

Spickzettel

STL-Algorithmen sind Template-Funktionen aus <algorithm> und <numeric>, die auf durch Iteratoren definierten Bereichen operieren.

std::sort ordnet Elemente 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 nichts 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 arbeiten mit Iterator-Bereichen, was sie flexibel für Teilbereiche oder verschiedene Containertypen macht.

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