152 lines
4.1 KiB
C++
152 lines
4.1 KiB
C++
#include <iostream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
#include <set>
|
|
#include <algorithm>
|
|
#include <numeric>
|
|
#include <stdexcept>
|
|
#include <cmath>
|
|
|
|
namespace cpp11 {
|
|
|
|
// 🎯 TODO 1: InventorySystem
|
|
class InventorySystem {
|
|
private:
|
|
std::unordered_map<std::string, int> stock_;
|
|
|
|
public:
|
|
void add_item(const std::string& name, int amount) {
|
|
if (amount > 0) {
|
|
stock_[name] += amount;
|
|
}
|
|
}
|
|
|
|
bool remove_item(const std::string& name, int amount) {
|
|
auto it = stock_.find(name);
|
|
if (it != stock_.end() && it->second >= amount && amount > 0) {
|
|
it->second -= amount;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
[[nodiscard]] int get_stock(const std::string& name) const {
|
|
auto it = stock_.find(name);
|
|
if (it != stock_.end()) {
|
|
return it->second;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
[[nodiscard]] std::size_t item_count() const {
|
|
return stock_.size();
|
|
}
|
|
};
|
|
|
|
// 🎯 TODO 2: filter_and_sort_leaderboard
|
|
struct PlayerRecord {
|
|
std::string name;
|
|
int score;
|
|
|
|
bool operator==(const PlayerRecord& other) const {
|
|
return name == other.name && score == other.score;
|
|
}
|
|
};
|
|
|
|
inline std::vector<PlayerRecord> filter_and_sort_leaderboard(
|
|
const std::vector<PlayerRecord>& records,
|
|
int min_score)
|
|
{
|
|
std::vector<PlayerRecord> filtered;
|
|
std::copy_if(records.begin(), records.end(), std::back_inserter(filtered),
|
|
[min_score](const PlayerRecord& p) {
|
|
return p.score >= min_score;
|
|
});
|
|
|
|
std::sort(filtered.begin(), filtered.end(),
|
|
[](const PlayerRecord& a, const PlayerRecord& b) {
|
|
if (a.score != b.score) {
|
|
return a.score > b.score; // Absteigend nach Score
|
|
}
|
|
return a.name < b.name; // Alphabetisch bei Gleichstand
|
|
});
|
|
|
|
return filtered;
|
|
}
|
|
|
|
// 🎯 TODO 3: calculate_telemetry_stats
|
|
struct TelemetryStats {
|
|
double min_val{0.0};
|
|
double max_val{0.0};
|
|
double average{0.0};
|
|
double total{0.0};
|
|
};
|
|
|
|
inline TelemetryStats calculate_telemetry_stats(const std::vector<double>& readings) {
|
|
if (readings.empty()) {
|
|
throw std::invalid_argument("Vector is empty");
|
|
}
|
|
|
|
TelemetryStats stats;
|
|
auto [min_it, max_it] = std::minmax_element(readings.begin(), readings.end());
|
|
stats.min_val = *min_it;
|
|
stats.max_val = *max_it;
|
|
stats.total = std::accumulate(readings.begin(), readings.end(), 0.0);
|
|
stats.average = stats.total / static_cast<double>(readings.size());
|
|
|
|
return stats;
|
|
}
|
|
|
|
// 🎯 TODO 4: extract_unique_sorted_tags
|
|
inline std::set<std::string> extract_unique_sorted_tags(
|
|
const std::vector<std::vector<std::string>>& document_tags)
|
|
{
|
|
std::set<std::string> unique_tags;
|
|
for (const auto& tags : document_tags) {
|
|
unique_tags.insert(tags.begin(), tags.end());
|
|
}
|
|
return unique_tags;
|
|
}
|
|
|
|
// 🎯 TODO 5: normalize_sensor_data
|
|
inline std::vector<double> normalize_sensor_data(const std::vector<double>& raw_data) {
|
|
if (raw_data.empty()) return {};
|
|
|
|
double min_val = *std::min_element(raw_data.begin(), raw_data.end());
|
|
double max_val = *std::max_element(raw_data.begin(), raw_data.end());
|
|
double range = max_val - min_val;
|
|
|
|
std::vector<double> result(raw_data.size());
|
|
|
|
if (std::fabs(range) < 1e-9) {
|
|
std::fill(result.begin(), result.end(), 0.0);
|
|
return result;
|
|
}
|
|
|
|
std::transform(raw_data.begin(), raw_data.end(), result.begin(),
|
|
[min_val, range](double val) {
|
|
return (val - min_val) / range;
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
} // namespace cpp11
|
|
|
|
int main() {
|
|
std::cout << "=== C++ 11: Musterlösung ===" << std::endl;
|
|
cpp11::InventorySystem inv;
|
|
inv.add_item("Diamond", 10);
|
|
std::cout << "Diamond count: " << inv.get_stock("Diamond") << "\n";
|
|
|
|
std::vector<cpp11::PlayerRecord> players = {
|
|
{"Alice", 80}, {"Bob", 120}, {"Charlie", 120}, {"Dave", 40}
|
|
};
|
|
auto ranked = cpp11::filter_and_sort_leaderboard(players, 50);
|
|
for (const auto& p : ranked) {
|
|
std::cout << p.name << ": " << p.score << "\n";
|
|
}
|
|
|
|
return 0;
|
|
}
|