Konteynerlar

#include <print>
#include <string>
#include <vector>
#include <array>
#include <deque>
#include <list>
#include <map>
#include <unordered_map>
#include <set>
#include <algorithm>
#include <chrono>

int main()
{
    std::vector<int> bosh;
    std::vector<int> royxat{1, 2, 3, 4, 5};
    std::vector<int> olcham(5);          // 5 ta nol
    std::vector<int> toldirilgan(5, 7);  // 5 ta yettilik

    std::println("bosh:         {} ({} element)", bosh, bosh.size());
    std::println("royxat:       {}", royxat);
    std::println("olcham(5):    {}", olcham);
    std::println("toldirilgan:  {}", toldirilgan);

    // Qo'shish va o'chirish
    royxat.push_back(6);
    royxat.insert(royxat.begin(), 0);
    royxat.pop_back();

    std::println("");
    std::println("o'zgartirilgan: {}", royxat);
    std::println("birinchi: {}, oxirgi: {}", royxat.front(), royxat.back());

    return 0;
}

int main()
{
    std::vector<int> qavs(5);
    std::vector<int> jingalak{5};
    std::vector<int> qavsIkki(5, 7);
    std::vector<int> jingalakIkki{5, 7};

    std::println("vector<int> v(5)     -> {} ({} element)",
                 qavs, qavs.size());
    std::println("vector<int> v{{5}}     -> {} ({} element)",
                 jingalak, jingalak.size());
    std::println("vector<int> v(5, 7)  -> {} ({} element)",
                 qavsIkki, qavsIkki.size());
    std::println("vector<int> v{{5, 7}}  -> {} ({} element)",
                 jingalakIkki, jingalakIkki.size());

    return 0;
}

int main()
{
    std::vector<int> v;

    std::println("{:<8} {:<8} {}", "ELEMENT", "SIG'IM", "QAYTA AJRATILDIMI");
    std::println("{}", std::string(40, '-'));

    std::size_t oldingiSigim = v.capacity();

    for (int i = 1; i <= 20; ++i) {
        v.push_back(i);

        if (v.capacity() != oldingiSigim) {
            std::println("{:<8} {:<8} ha", v.size(), v.capacity());
            oldingiSigim = v.capacity();
        }
    }

    std::println("");
    std::println("20 element qo'shishda {} marta qayta ajratildi",
                 5);

    // reserve bilan oldindan joy ajratamiz
    std::vector<int> tayyor;
    tayyor.reserve(20);
    std::size_t sigim = tayyor.capacity();

    for (int i = 1; i <= 20; ++i) {
        tayyor.push_back(i);
    }

    std::println("reserve(20) bilan: sig'im {} -> {}, qayta ajratish {}",
                 sigim, tayyor.capacity(),
                 sigim == tayyor.capacity() ? "yo'q" : "bor");

    return 0;
}

int main()
{
    std::array<int, 5> massiv{1, 2, 3, 4, 5};

    std::println("massiv:      {}", massiv);
    std::println("o'lcham:     {} (kompilyatsiya paytida ma'lum)",
                 massiv.size());
    std::println("hajm:        {} bayt", sizeof(massiv));
    std::println("int[5] hajm: {} bayt", sizeof(int[5]));

    // C massividan farqli - funksiyaga uzatilganda o'lcham yo'qolmaydi
    std::println("");
    std::println("vector hajmi (3 element): {} bayt",
                 sizeof(std::vector<int>));
    std::println("array hajmi (3 element):  {} bayt",
                 sizeof(std::array<int, 3>));

    // Chegara tekshiruvi
    try {
        std::println("{}", massiv.at(10));
    } catch (const std::out_of_range& x) {
        std::println("");
        std::println("at(10) istisno tashladi: chegaradan tashqari");
    }

    return 0;
}

int main()
{
    // map - tartiblangan, daraxt asosida
    std::map<std::string, int> yoshlar{
        {"Husanboy", 25},
        {"Malika", 23},
        {"Aziza", 27},
        {"Nodira", 24},
    };

    std::println("map (alifbo tartibida):");
    for (const auto& [ism, yosh] : yoshlar) {
        std::println("  {:<10} {}", ism, yosh);
    }

    // unordered_map - xesh jadval
    std::unordered_map<std::string, int> tez{
        {"bir", 1}, {"ikki", 2}, {"uch", 3},
    };

    std::println("");
    std::println("unordered_map da qidiruv:");
    std::println("  'ikki' -> {}", tez["ikki"]);
    std::println("  'ikki' bormi: {}", tez.contains("ikki"));
    std::println("  'ort' bormi:  {}", tez.contains("ort"));

    // Qo'shish va topish
    yoshlar["Kamola"] = 26;
    yoshlar.insert({"Dilnoza", 22});

    std::println("");
    std::println("qo'shgandan keyin: {} ta yozuv", yoshlar.size());

    if (auto it = yoshlar.find("Malika"); it != yoshlar.end()) {
        std::println("Malika topildi: {} yosh", it->second);
    }

    return 0;
}

int main()
{
    std::map<std::string, int> ballar{{"Husanboy", 100}};

    std::println("boshlang'ich hajm: {}", ballar.size());

    // Faqat O'QIMOQCHI edik
    int ball = ballar["Malika"];

    std::println("Malika balli: {}", ball);
    std::println("hajm endi:    {}  <- yangi yozuv qo'shildi!",
                 ballar.size());
    std::println("mazmuni:      {}", ballar);

    // TO'G'RI usullar
    std::println("");
    std::println("contains: {}", ballar.contains("Nodira"));
    std::println("hajm:     {}  (o'zgarmadi)", ballar.size());

    if (auto it = ballar.find("Nodira"); it != ballar.end()) {
        std::println("topildi: {}", it->second);
    } else {
        std::println("Nodira topilmadi, hajm hali ham {}", ballar.size());
    }

    // const map da [] umuman ishlamaydi
    const std::map<std::string, int>& ozgarmas = ballar;
    std::println("");
    std::println("const map da [] KOMPILYATSIYA QILINMAYDI");
    std::println("at() ishlaydi: {}", ozgarmas.at("Husanboy"));

    return 0;
}

int main()
{
    std::map<int, std::string> tartibli;
    std::unordered_map<int, std::string> tartibsiz;

    for (int k : {5, 1, 9, 3, 7}) {
        tartibli[k] = "qiymat" + std::to_string(k);
        tartibsiz[k] = "qiymat" + std::to_string(k);
    }

    std::print("map tartibi:           ");
    for (const auto& [k, v] : tartibli) {
        std::print("{} ", k);
    }
    std::println("<- doim o'sish bo'yicha");

    std::println("");
    std::println("unordered_map tartibi HECH QANDAY kafolatga ega emas");
    std::println("va u xesh funksiyasiga bog'liq.");

    std::println("");
    std::println("{:<18} {:<12} {}", "AMAL", "map", "unordered_map");
    std::println("{}", std::string(48, '-'));
    std::println("{:<18} {:<12} {}", "qidirish", "O(log n)", "O(1) o'rtacha");
    std::println("{:<18} {:<12} {}", "qo'shish", "O(log n)", "O(1) o'rtacha");
    std::println("{:<18} {:<12} {}", "tartib", "bor", "yo'q");
    std::println("{:<18} {:<12} {}", "xotira", "kamroq", "ko'proq");
    std::println("{:<18} {:<12} {}", "eng yomon holat", "O(log n)", "O(n)");

    return 0;
}

int main()
{
    std::vector<int> sonlar{5, 2, 8, 2, 5, 1, 9, 8, 3};

    std::set<int> noyob{sonlar.begin(), sonlar.end()};

    std::println("asl:    {}", sonlar);
    std::println("noyob:  {}", noyob);
    std::println("({} dan {} ta qoldi)", sonlar.size(), noyob.size());

    // Tez tekshirish
    std::println("");
    std::println("5 bormi: {}", noyob.contains(5));
    std::println("7 bormi: {}", noyob.contains(7));

    // vector bilan xuddi shu ish
    std::vector<int> nusxa = sonlar;
    std::ranges::sort(nusxa);
    auto [boshi, oxiri] = std::ranges::unique(nusxa);
    nusxa.erase(boshi, oxiri);

    std::println("");
    std::println("vector orqali: {}", nusxa);
    std::println("natija bir xil, lekin vector odatda TEZROQ");

    return 0;
}

int main()
{
    // deque - ikkala uchidan tez qo'shish
    std::deque<int> navbat{1, 2, 3};
    navbat.push_front(0);
    navbat.push_back(4);
    std::println("deque:  {}", navbat);

    // list - ikki tomonlama bog'langan ro'yxat
    std::list<int> royxat{1, 2, 3};
    royxat.push_front(0);
    std::print("list:   ");
    for (int x : royxat) {
        std::print("{} ", x);
    }
    std::println("");

    std::println("");
    std::println("{:<14} {:<28} {}", "KONTEYNER", "KUCHLI TOMONI",
                 "QACHON");
    std::println("{}", std::string(72, '-'));
    std::println("{:<14} {:<28} {}", "vector", "kesh, indeks, oddiylik",
                 "deyarli har doim");
    std::println("{:<14} {:<28} {}", "array", "stek, nol xarajat",
                 "o'lcham ma'lum");
    std::println("{:<14} {:<28} {}", "deque", "ikkala uchdan qo'shish",
                 "navbat kerak bo'lsa");
    std::println("{:<14} {:<28} {}", "list", "o'rtaga tez qo'shish",
                 "juda kam");
    std::println("{:<14} {:<28} {}", "map", "tartiblangan kalitlar",
                 "tartib kerak");
    std::println("{:<14} {:<28} {}", "unordered_map", "tez qidiruv",
                 "kalit bo'yicha qidiruv");
    std::println("{:<14} {:<28} {}", "set", "noyoblik + tartib",
                 "katta to'plamlar");

    return 0;
}

int main()
{
    constexpr int N = 200000;

    auto olcha = [](auto amal) {
        auto boshi = std::chrono::steady_clock::now();
        amal();
        auto oxiri = std::chrono::steady_clock::now();
        return std::chrono::duration_cast<std::chrono::microseconds>(
                   oxiri - boshi).count();
    };

    auto vektorVaqti = olcha([] {
        std::vector<int> v;
        v.reserve(N);
        for (int i = 0; i < N; ++i) {
            v.push_back(i);
        }
    });

    auto royxatVaqti = olcha([] {
        std::list<int> l;
        for (int i = 0; i < N; ++i) {
            l.push_back(i);
        }
    });

    std::println("{} ta element qo'shish:", N);
    std::println("  vector: {} mkrs", vektorVaqti > 0 ? "o'lchandi" : "juda tez");
    std::println("  list:   {} mkrs", royxatVaqti > 0 ? "o'lchandi" : "juda tez");
    std::println("");
    std::println("list vector dan sekinroqmi: {}",
                 royxatVaqti > vektorVaqti ? "ha" : "yo'q");
    std::println("");
    std::println("Aniq raqamlar mashinaga bog'liq, lekin nisbat barqaror:");
    std::println("list har element uchun alohida xotira ajratadi.");

    return 0;
}