Algoritmi STL

Fa parte della sezione Programmazione orientata agli oggetti del percorso C++ di Coddy. Lezione 73 di 104.

Gli algoritmi STL sono funzioni template che operano su intervalli definiti da iteratori. Si trovano negli header <algorithm> e <numeric> e funzionano con qualsiasi contenitore che fornisca iteratori compatibili.

std::sort dispone gli elementi in ordine crescente per impostazione predefinita:

#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 cerca un valore e restituisce un iteratore alla prima corrispondenza, oppure end() se non viene trovato:

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

std::transform applica un'operazione a ogni elemento e memorizza i risultati in un intervallo di destinazione:

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 di <numeric> combina tutti gli elementi in un unico valore:

#include <numeric>

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

Questi algoritmi accettano intervalli di iteratori anziché contenitori direttamente, il che li rende abbastanza flessibili da funzionare su intervalli parziali o su diversi tipi di contenitori con lo stesso codice.

Sfida

Facile

Costruiamo un analizzatore di punteggi che elabora una raccolta di numeri usando gli algoritmi STL. Creerai funzioni di utilità che mostrano come sort, find, transform e accumulate collaborano per analizzare i dati.

Organizzerai il codice in due file:

ScoreAnalyzer.h: definisci funzioni di utilità che usano gli algoritmi STL per elaborare vettori di interi.
Crea una funzione chiamata sortScores che accetta un std::vector<int>& e lo ordina in ordine crescente usando std::sort.

Crea una funzione chiamata findScore che accetta un const std::vector<int>& e un valore obiettivo di tipo int. Usa std::find per cercare il valore obiettivo. Se viene trovato, restituisci l'indice (la distanza da begin). Se non viene trovato, restituisci -1.

Crea una funzione chiamata applyBonus che accetta un const std::vector<int>& e un bonus di tipo int. Usa std::transform per creare e restituire un nuovo vettore in cui a ogni punteggio viene aggiunto il bonus.

Crea una funzione chiamata calculateAverage che accetta un const std::vector<int>& e restituisce la media come double. Usa std::accumulate per calcolare la somma, quindi dividila per la dimensione.

Crea una funzione chiamata printVector che accetta un const std::vector<int>& e stampa tutti gli elementi separati da spazi, seguiti da una nuova riga.
main.cpp: leggi sei valori (ciascuno su una riga separata):
1. Primo punteggio (intero)
2. Secondo punteggio (intero)
3. Terzo punteggio (intero)
4. Quarto punteggio (intero)
5. Un punteggio da cercare (intero)
6. Un bonus da applicare (intero)
Crea un vettore con i quattro punteggi e mostra gli algoritmi:
1. Stampa Original: seguito dagli elementi del vettore
2. Ordina i punteggi e stampa Sorted: seguito dal vettore ordinato
3. Cerca il punteggio obiettivo nel vettore ordinato. Se viene trovato, stampa Found <value> at index <index>. Se non viene trovato, stampa <value> not found
4. Applica il bonus ai punteggi ordinati e stampa With bonus: seguito dal nuovo vettore
5. Calcola e stampa la media dei punteggi ordinati originali (prima del bonus) come Average: <value> con una cifra decimale

Per esempio, con i valori 75, 90, 60, 85, 85 e 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

Con i valori 100, 80, 95, 70, 50 e 10:

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

Ricorda di includere <algorithm> per sort, find e transform, e <numeric> per accumulate. Usa std::fixed e std::setprecision(1) da <iomanip> per formattare la media.

Provalo tu

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

using namespace std;

int main() {
    // Leggi sei valori di input
    int score1, score2, score3, score4;
    int searchTarget, bonusAmount;
    
    cin >> score1;
    cin >> score2;
    cin >> score3;
    cin >> score4;
    cin >> searchTarget;
    cin >> bonusAmount;
    
    // TODO: Crea un vector con i quattro punteggi
    
    // TODO: Stampa "Original:" seguito dal contenuto del vector
    
    // TODO: Ordina i punteggi e stampa "Sorted:" seguito dal vector ordinato
    
    // TODO: Cerca il punteggio desiderato nel vector ordinato
    // Se viene trovato, stampa "Found <value> at index <index>"
    // Se non viene trovato, stampa "<value> not found"
    
    // TODO: Applica il bonus ai punteggi ordinati e stampa "With bonus:" seguito dal nuovo vector
    
    // TODO: Calcola e stampa la media dei punteggi ordinati (prima del bonus)
    // Usa fixed e setprecision(1) per la formattazione
    // Stampa nel formato "Average: <value>"
    
    return 0;
}