STL కంటైనర్లు & అల్గారిథమ్స్

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers;
    numbers.reserve(5); // 5 ఎలిమెంట్లకు ముందుగానే కెపాసిటీ లాక్!

    std::cout << "ప్రారంభ సైజ్: " << numbers.size() << " | కెపాసిటీ: " << numbers.capacity() << "\n";

    for (int i = 1; i <= 5; ++i) {
        numbers.push_back(i * 10);
        std::cout << "ఐటెమ్ జోడించబడింది: " << (i * 10) 
                  << " -> Size: " << numbers.size() << " | Capacity: " << numbers.capacity() << "\n";
    }

    // emplace_back: ఆబ్జెక్ట్‌ను ఇన్-ప్లేస్ గా నిర్మిస్తుంది (కాపీ సున్నా!)
    numbers.emplace_back(60); // ఇప్పుడు కెపాసిటీ రెట్టింపు అవుతుంది!
    std::cout << "60 చేర్చిన తర్వాత -> Size: " << numbers.size() << " | Capacity: " << numbers.capacity() << "\n";
    return 0;
}

#include <iostream>
#include <queue>
#include <string>

struct HospitalPatient {
    std::string name;
    int triagePriority; // 10: అత్యవసరం (ICU), 1: సాధారణం

    // Priority Queue కొరకు < ఆపరేటర్ ఓవర్‌లోడింగ్!
    bool operator<(const HospitalPatient& other) const {
        return triagePriority < other.triagePriority; // Max-heap కొరకు
    }
};

int main() {
    std::priority_queue<HospitalPatient> erQueue;

    erQueue.push({"రోగి A (సాధారణ జ్వరం)", 2});
    erQueue.push({"రోగి B (గుండెపోటు - ICU)", 10});
    erQueue.push({"రోగి C (ఎముక విరిగింది)", 6});

    std::cout << "===== అత్యవసర ఎమర్జెన్సీ వార్డ్ ట్రియేజ్ ఆర్డర్ =====\n";
    while (!erQueue.empty()) {
        HospitalPatient p = erQueue.top();
        std::cout << "🚨 చికిత్స జరుగుతోంది: " << p.name << " [ప్రాధాన్యత: " << p.triagePriority << "]\n";
        erQueue.pop();
    }
    return 0;
}

#include <iostream>
#include <map>
#include <string>

int main() {
    // std::map కీలను స్వయంచాలకంగా ఆల్ఫాబెటికల్ ఆర్డర్‌లో సార్ట్ చేస్తుంది!
    std::map<std::string, double> currencyRates;

    currencyRates["USD"] = 84.15;
    currencyRates["EUR"] = 91.20;
    currencyRates["GBP"] = 108.50;
    currencyRates["AED"] = 22.90;

    std::cout << "===== కరెన్సీ రేట్లు (ఆటోమేటిక్ Sorted Order) =====\n";
    for (const auto& [currency, rate] : currencyRates) {
        std::cout << "  " << currency << " = ₹ " << rate << "\n";
    }

    // find() ద్వారా సురక్షిత సెర్చింగ్
    auto it = currencyRates.find("EUR");
    if (it != currencyRates.end()) {
        std::cout << "\nEUR రేటు లభించింది: ₹ " << it->second << "\n";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> scores = {85, 42, 99, 12, 73, 56, 91};

    // 1. std::sort తో ఆరోహణ క్రమం
    std::sort(scores.begin(), scores.end());

    std::cout << "సార్ట్ చేసిన మార్కులు: ";
    for (int s : scores) std::cout << s << " ";
    std::cout << "\n";

    // 2. Binary Search (ఖచ్చితంగా డేటా సార్ట్ అయి ఉండాలి!)
    bool found = std::binary_search(scores.begin(), scores.end(), 73);
    std::cout << "73 మార్కులు లిస్టులో ఉన్నాయా? " << (found ? "అవును (Found)" : "లేవు (Not Found)") << "\n";
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<double> pricesUSD = {10.0, 25.5, 40.0, 100.0};
    std::vector<double> pricesINR(pricesUSD.size());

    const double exchangeRate = 84.0;

    // std::transform తో USD ని నేరుగా INR గా మార్చడం
    std::transform(pricesUSD.begin(), pricesUSD.end(), pricesINR.begin(),
                   [exchangeRate](double usd) { return usd * exchangeRate; });

    // std::accumulate తో మొత్తం బిల్లు కూడటం
    double totalBillINR = std::accumulate(pricesINR.begin(), pricesINR.end(), 0.0);

    std::cout << "భారతీయ రూపాయల్లో మొత్తం బిల్లు: ₹ " << totalBillINR << "\n";
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <unordered_map>
#include <map>
#include <queue>
#include <algorithm>
#include <numeric>
#include <iomanip>

struct Product {
    std::string sku;
    std::string title;
    double price;
    std::string category;
};

struct Order {
    int orderId;
    std::string customerName;
    std::vector<std::string> skus;
    int deliveryUrgency; // 10: Prime Same-Day, 1: Standard

    bool operator<(const Order& other) const {
        return deliveryUrgency < other.deliveryUrgency; // Priority Queue కొరకు
    }
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "🛒 [ENTERPRISE E-COMMERCE ORDER FULFILMENT & ANALYTICS ENGINE]\n";
    std::cout << "=======================================================================\n";

    // 1. std::unordered_map: O(1) ప్రొడక్ట్ క్యాటలాగ్ ఇండెక్స్
    std::unordered_map<std::string, Product> catalog = {
        {"SKU_001", {"SKU_001", "MacBook Pro M3 Max", 249900.0, "Electronics"}},
        {"SKU_002", {"SKU_002", "Sony WH-1000XM5 Headphones", 29990.0, "Audio"}},
        {"SKU_003", {"SKU_003", "Ergonomic Mechanical Keyboard", 12499.0, "Accessories"}},
        {"SKU_004", {"SKU_004", "Dell UltraSharp 4K Monitor", 58990.0, "Electronics"}}
    };

    // 2. std::priority_queue: ఎక్స్‌ప్రెస్ ప్రైమ్ ఆర్డర్ ఫుల్‌ఫిల్‌మెంట్ క్యూ
    std::priority_queue<Order> fulfilmentQueue;

    fulfilmentQueue.push({1001, "రాజేష్ వర్మ", {"SKU_002"}, 3});
    fulfilmentQueue.push({1002, "ప్రియాంక రెడ్డి (PRIME VIP)", {"SKU_001", "SKU_004"}, 10});
    fulfilmentQueue.push({1003, "సందీప్ కుమార్", {"SKU_003"}, 5});

    std::cout << "\n[వేర్‌హౌస్ డిస్పాచ్ ఆర్డర్ ప్రాసెసింగ్ (Priority Queue ద్వారా)]:\n";
    double totalRevenue = 0.0;

    while (!fulfilmentQueue.empty()) {
        Order currentOrder = fulfilmentQueue.top();
        fulfilmentQueue.pop();

        std::cout << "  📦 ఆర్డర్ #" << currentOrder.orderId << " కస్టమర్: " << currentOrder.customerName 
                  << " [Urgency Level: " << currentOrder.deliveryUrgency << "]\n";

        double orderTotal = 0.0;
        for (const auto& sku : currentOrder.skus) {
            if (catalog.find(sku) != catalog.end()) {
                const auto& prod = catalog[sku];
                std::cout << "     • ఐటెమ్: " << prod.title << " | ₹ " << prod.price << "\n";
                orderTotal += prod.price;
            }
        }
        std::cout << "     -> ఆర్డర్ సబ్‌టోటల్: ₹ " << orderTotal << "\n\n";
        totalRevenue += orderTotal;
    }

    std::cout << "=======================================================================\n";
    std::cout << "💰 మొత్తం ప్రాసెస్ చేయబడిన టర్నోవర్: ₹ " << std::fixed << std::setprecision(2) << totalRevenue << "\n";
    std::cout << "=======================================================================\n";
    return 0;
}