STL Algoritmaları

Coddy'nin C++ Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 73 / 104.

STL algoritmaları, iteratörler tarafından tanımlanan aralıklar üzerinde işlem yapan şablon fonksiyonlardır. <algorithm> ve <numeric> başlık dosyalarında bulunurlar ve uyumlu iteratörler sağlayan herhangi bir konteyner ile çalışırlar.

std::sort varsayılan olarak öğeleri artan düzende sıralar:

#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 bir değeri arar ve ilk eşleşmeye bir yineleyici (iterator) döndürür, veya bulunamazsa end() döndürür:

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

std::transform her bir öğeye bir işlem uygular ve sonuçları bir hedef aralıkta saklar:

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

<numeric> başlığındaki std::accumulate, tüm öğeleri tek bir değerde birleştirir:

#include <numeric>

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

Bu algoritmalar, doğrudan konteynerler yerine yineleyici aralıklarını (iterator ranges) kabul eder; bu da onları kısmi aralıklar veya aynı kodla farklı konteyner türleri üzerinde çalışacak kadar esnek hale getirir.

Görev

Kolay

STL algoritmalarını kullanarak bir sayı koleksiyonunu işleyen bir puan analizörü oluşturalım. Verileri analiz etmek için sort, find, transform ve accumulate algoritmalarının birlikte nasıl çalıştığını gösteren yardımcı işlevler oluşturacaksın.

Kodunu iki dosya arasında düzenleyeceksin:

ScoreAnalyzer.h: Tamsayı vektörlerini işlemek için STL algoritmalarını kullanan yardımcı işlevleri tanımla.
sortScores alan ve std::vector<int>& kullanarak vektörü artan düzende sıralayan std::sort adlı bir işlev oluştur.

findScore ve bir const std::vector<int>& hedef değeri alan int adlı bir işlev oluştur. Hedefi aramak için std::find kullan. Bulunursa dizini (başlangıçtan olan uzaklığı) döndür. Bulunamazsa -1 döndür.

applyBonus ve bir const std::vector<int>& bonus miktarı alan int adlı bir işlev oluştur. Her puana bonusun eklendiği yeni bir vektör oluşturup döndürmek için std::transform kullan.

calculateAverage alan ve ortalamayı const std::vector<int>& olarak döndüren double adlı bir işlev oluştur. Toplamı hesaplamak için std::accumulate kullan, ardından boyuta böl.

printVector alan ve tüm elemanları aralarında boşluk olacak şekilde, ardından bir yeni satır karakteriyle yazdıran const std::vector<int>& adlı bir işlev oluştur.
main.cpp: Altı girdi oku (her biri ayrı bir satırda):
1. Birinci puan (tamsayı)
2. İkinci puan (tamsayı)
3. Üçüncü puan (tamsayı)
4. Dördüncü puan (tamsayı)
5. Aranacak bir puan (tamsayı)
6. Uygulanacak bonus miktarı (tamsayı)
Dört puandan oluşan bir vektör oluştur ve algoritmaları göster:
1. Vektör içeriğinden önce Original: yazdır
2. Puanları sırala ve sıralanmış vektörden önce Sorted: yazdır
3. Sıralanmış vektörde hedef puanı ara. Bulunursa Found <value> at index <index> yazdır. Bulunamazsa <value> not found yazdır
4. Sıralanmış puanlara bonusu uygula ve yeni vektörden önce With bonus: yazdır
5. Bonus uygulanmadan önceki özgün sıralanmış puanların ortalamasını hesapla ve bir ondalık basamakla Average: <value> olarak yazdır

Örneğin, girdiler 75, 90, 60, 85, 85 ve 5 olduğunda:

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

Girdiler 100, 80, 95, 70, 50 ve 10 olduğunda:

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

<algorithm>, sort ve find için transform; <numeric> için ise accumulate eklemeyi unutma. Ortalamayı biçimlendirmek için std::fixed içindeki std::setprecision(1) ve <iomanip> kullan.

Kendin dene

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

using namespace std;

int main() {
    // Altı girişi oku
    int score1, score2, score3, score4;
    int searchTarget, bonusAmount;
    
    cin >> score1;
    cin >> score2;
    cin >> score3;
    cin >> score4;
    cin >> searchTarget;
    cin >> bonusAmount;
    
    // TODO: Dört puanı içeren bir vector oluşturun
    
    // TODO: "Original:" yazdırın ve ardından vector içeriğini yazdırın
    
    // TODO: Puanları sıralayın ve "Sorted:" yazdırın, ardından sıralanmış vector'ü yazdırın
    
    // TODO: Sıralanmış vector içinde hedef puanı arayın
    // Eğer bulunursa, "Found <value> at index <index>" yazdırın
    // Eğer bulunamazsa, "<value> not found" yazdırın
    
    // TODO: Sıralanmış puanlara bonusu uygulayın ve "With bonus:" yazdırın, ardından yeni vector'ü yazdırın
    
    // TODO: Sıralanmış puanların ortalamasını (bonustan önce) hesaplayın ve yazdırın
    // Biçimlendirme için fixed ve setprecision(1) kullanın
    // "Average: <value>" şeklinde yazdırın
    
    return 0;
}