এসটিএল কন্টেইনার (STL Containers)

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> freq;
    string words[] = {"apple", "banana", "apple", "cherry", "banana", "apple"};

    for (const auto& w : words) {
        freq[w]++;  // operator[] মূলত কোনো কিছু মিসিং (missing) থাকলে একটি এন্ট্রি তৈরি করে (creates entry)
    }

    // ম্যাপ (map) মূলত কি বা key অনুযায়ী সাজানো (sorted) থাকে!
    for (const auto& [word, count] : freq) {
        cout << word << ": " << count << endl;
    }

    return 0;
}

apple: 3
banana: 2
cherry: 1

#include <iostream>
#include <set>
using namespace std;

int main() {
    set<int> s;
    s.insert(5);
    s.insert(2);
    s.insert(8);
    s.insert(2);  // ডুপ্লিকেট বা duplicate — এটি ইগনোরড বা ignored হয়ে যাবে
    s.insert(5);  // ডুপ্লিকেট বা duplicate — এটি ইগনোরড বা ignored হয়ে যাবে

    cout << "Size: " << s.size() << endl;
    cout << "Elements: ";
    for (int x : s) cout << x << " ";
    cout << endl;

    // দ্রুত লুকআপ বা Fast lookup
    if (s.count(8)) cout << "Found 8!" << endl; // 8 পাওয়া গেছে বা Found 8!
    if (!s.count(99)) cout << "99 not found" << endl; // 99 পাওয়া যায়নি বা 99 not found

    return 0;
}

Size: 3
Elements: 2 5 8
Found 8!
99 not found

#include <iostream>
#include <map>
#include <unordered_map>
#include <chrono>
using namespace std;
using namespace chrono;

int main() {
    const int N = 1000000;

    // --- ম্যাপ বা map (সাজানো বা sorted, O(log n)) ---
    map<int, int> ordered;
    auto t1 = high_resolution_clock::now();
    for (int i = 0; i < N; i++) ordered[i] = i;
    auto t2 = high_resolution_clock::now();
    cout << "map insert: "
         << duration_cast<milliseconds>(t2 - t1).count()
         << " ms" << endl;

    // --- আনঅর্ডারড ম্যাপ বা unordered_map (হ্যাশ বা hash, গড় O(1) বা O(1) avg) ---
    unordered_map<int, int> hashed;
    t1 = high_resolution_clock::now();
    for (int i = 0; i < N; i++) hashed[i] = i;
    t2 = high_resolution_clock::now();
    cout << "unordered_map insert: "
         << duration_cast<milliseconds>(t2 - t1).count()
         << " ms" << endl;

    return 0;
}

map insert: 612 ms
unordered_map insert: 198 ms

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int main() {
    // ডিফল্ট (Default): ম্যাক্স-হিপ বা max-heap (সবচেয়ে বড়টি বা largest সবার ওপরে থাকে)
    priority_queue<int> maxPQ;
    for (int x : {3, 1, 4, 1, 5, 9, 2, 6}) {
        maxPQ.push(x);
    }

    cout << "Top 3 largest: "; // শীর্ষ তিনটি বা Top 3 সবচেয়ে বড় এলিমেন্ট বা largest:
    for (int i = 0; i < 3; i++) {
        cout << maxPQ.top() << " ";
        maxPQ.pop();
    }
    cout << endl;

    // মিন-হিপ বা Min-heap: greater<int> ব্যবহার করুন
    priority_queue<int, vector<int>, greater<int>> minPQ;
    for (int x : {3, 1, 4, 1, 5, 9, 2, 6}) {
        minPQ.push(x);
    }

    cout << "Top 3 smallest: "; // শীর্ষ তিনটি বা Top 3 সবচেয়ে ছোট এলিমেন্ট বা smallest:
    for (int i = 0; i < 3; i++) {
        cout << minPQ.top() << " ";
        minPQ.pop();
    }
    cout << endl;

    return 0;
}

Top 3 largest: 9 6 5
Top 3 smallest: 1 1 2

#include <iostream>
#include <stack>
#include <string>
using namespace std;

bool isBalanced(const string& expr) {
    stack<char> s;
    for (char c : expr) {
        if (c == '(' || c == '[' || c == '{') {
            s.push(c);
        } else if (c == ')' || c == ']' || c == '}') {
            if (s.empty()) return false;
            char top = s.top(); s.pop();
            if ((c == ')' && top != '(') ||
                (c == ']' && top != '[') ||
                (c == '}' && top != '{'))
                return false;
        }
    }
    return s.empty();
}

int main() {
    cout << "{[()]}  -> " << (isBalanced("{[()]}") ? "balanced" : "not balanced") << endl; // ব্যালেন্সড (balanced) বা নট ব্যালেন্সড (not balanced)
    cout << "{[(])}  -> " << (isBalanced("{[(])}") ? "balanced" : "not balanced") << endl;
    cout << "((()))  -> " << (isBalanced("((()))") ? "balanced" : "not balanced") << endl;

    return 0;
}

{[()]}  -> balanced
{[(])}  -> not balanced
((()))  -> balanced