C++ কোডিং ইন্টারভিউ — সমস্যা থেকে সমাধান

১ · C++ কোডিং ইন্টারভিউ কী যাচাই করে

পর্ব ৫৪-এ দেখেছেন লিখিত ও মৌখিক পরীক্ষায় কীভাবে উত্তর গোছাতে হয়। সফটওয়্যার কোম্পানির technical interview একটু আলাদা। এখানে শুধু “উত্তর জানেন কি না” দেখা হয় না। দেখা হয়, অচেনা একটি সমস্যা পেলে আপনি কীভাবে ভাবেন, কীভাবে কথা বলেন, আর কতটা নির্ভরযোগ্য কোড লেখেন।

দেশি স্টার্টআপ, সফটওয়্যার ফার্ম, গেম স্টুডিও, ব্যাংকের আইটি বিভাগ বা বহুজাতিক কোম্পানি — প্রতিষ্ঠানভেদে ধাপের নাম ও সংখ্যা আলাদা। তবে কাঠামোটা সাধারণত এমন:

ইন্টারভিউয়ারের মূল্যায়ন-পত্রে কী থাকে

অনেকে ভাবেন, “সঠিক কোড লিখলেই পাস।” বাস্তবে মূল্যায়নে সাধারণত কয়েকটি আলাদা ঘর থাকে। ঠিক কোড লিখেও কেউ পিছিয়ে পড়েন, আবার কোড শেষ না করেও কেউ ভালো করেন — যদি বাকি ঘরগুলো শক্ত হয়।

C++-নির্দিষ্ট প্রশ্ন দেখতে কেমন

সাধারণ অ্যালগরিদমের প্রশ্ন যেকোনো ভাষায় করা যায়। কিন্তু C++ পদের ইন্টারভিউতে প্রায়ই এমন প্রশ্নও আসে, যেখানে ভাষাটাই আসল বিষয়:

• “RAII দিয়ে একটি class লিখুন” — যেমন একটি ফাইল হ্যান্ডেল, যা destructor-এ নিজেই বন্ধ হয় (পর্ব ১৭, ২১)।
• “একটি Rule-of-Five টাইপ লিখুন” — নিজে মেমরি রাখা একটি Buffer, যার copy গভীর আর move সস্তা (পর্ব ২২, ৩৬)।
• “একটি LRU cache ডিজাইন করুন” — get ও put দুটোই O(1); এখানে container বাছাইটাই পরীক্ষা (পর্ব ৩০–৩২)।
• “একটি thread-safe counter বা queue লিখুন” — mutex, condition variable আর atomic-এর সঠিক ব্যবহার (পর্ব ৪৫–৪৬)।

এই পাতার ১৬টি সমস্যা

২ · সমস্যা থেকে সমাধান — সাত ধাপের পদ্ধতি

ইন্টারভিউর চাপে মাথা ফাঁকা হয়ে যাওয়া খুব স্বাভাবিক। এর সবচেয়ে ভালো ওষুধ একটি বাঁধা পদ্ধতি — যাতে “এখন কী করব” ভাবতে না হয়, শুধু পরের ধাপে যেতে হয়। ক্রিকেটে ব্যাটসম্যান যেমন প্রতিটি বলের আগে একই রুটিন মানেন — গার্ড নেওয়া, ফিল্ডিং দেখা, তারপর স্টান্স — এটাও তেমন।

এবার পদ্ধতিটি একটি বিখ্যাত সমস্যায় প্রয়োগ করি — সমস্যা ১ · Two sum (সহজ): “একটি std::vector<int> আর একটি target দেওয়া আছে। এমন দুটি ভিন্ন index বের করুন, যাদের মানের যোগফল target.” নিচের ডায়াগ্রামে “পরে” চাপুন:

- উত্তর সবসময় থাকবে, নাকি নাও থাকতে পারে?
- একই index দুবার নেওয়া যাবে? (না)
- vector কি সাজানো? (না)
- n কত বড়? মান কত বড়? ঋণাত্মক আছে?
- index ফেরত দেব, নাকি মান?

[2, 7, 11, 15], target 9  ->  (0, 1)
[3, 3],         target 6  ->  (0, 1)  একই মান, ভিন্ন index
[-3, 4, 3, 90], target 0  ->  (0, 2)  ঋণাত্মক
[5],            target 10 ->  নেই     5+5 চলবে না

for i in 0..n-1:
    for j in i+1..n-1:
        if a[i] + a[j] == target: return (i, j)
সময় O(n²), বাড়তি মেমরি O(1)

ভেতরের লুপ শুধু একটা প্রশ্ন করে:
  "target - a[j] কি আগে দেখেছি?"
-> দেখা মানগুলো unordered_map-এ রাখি
   (মান -> index), খোঁজা গড়ে O(1)

for j in 0..n-1:
    if seen আছে (target - a[j]): return (seen[..], j)
    seen[a[j]] = j      // আগে খুঁজি, পরে রাখি
return nullopt          // "নেই" টাইপেই বলা

j=0: need=3, seen-এ নেই    -> seen{3:0}
j=1: need=3, seen-এ আছে(0) -> (0, 1)
উল্টো ক্রমে (আগে রাখি, পরে খুঁজি) [5], 10
-> নিজের সাথেই জোড়া (0, 0) — ভুল!

Hash: সময় O(n) গড়ে, মেমরি O(n)
- vector সাজানো হলে? -> দুই পয়েন্টার, O(1) মেমরি
- সব জোড়া চাই? 3-sum? -> সাজিয়ে + দুই পয়েন্টার, O(n²)
- target - a[j] কি overflow করতে পারে?

#include <optional>
#include <print>
#include <unordered_map>
#include <utility>
#include <vector>

std::optional<std::pair<int, int>> two_sum(const std::vector<int>& a, int target) {
    std::unordered_map<int, int> seen;               // value -> index
    seen.reserve(a.size());
    for (int j = 0; j < std::ssize(a); ++j) {
        if (auto it = seen.find(target - a[j]); it != seen.end())
            return std::pair{it->second, j};         // look first ...
        seen.emplace(a[j], j);                       // ... then insert
    }
    return std::nullopt;
}

int main() {
    const std::vector<std::vector<int>> tests{{2, 7, 11, 15}, {3, 3}, {-3, 4, 3, 90}, {5}};
    const int targets[]{9, 6, 0, 10};
    for (std::size_t t = 0; t < tests.size(); ++t) {
        if (auto r = two_sum(tests[t], targets[t])) std::println("({}, {})", r->first, r->second);
        else std::println("no pair");
    }
}

৩ · অ্যারে, স্ট্রিং ও হ্যাশিং — প্রথম সারির প্রশ্ন

প্রায় প্রতিটি ইন্টারভিউর প্রথম প্রশ্ন এই গোত্রের। দেখতে সহজ, কিন্তু এখানেই বোঝা যায় আপনি std::string_view, const&, range-for আর STL algorithm স্বাভাবিকভাবে ব্যবহার করেন কি না। রিভিশনের জন্য: পর্ব ১৩ · vector ও array, পর্ব ১৪ · string ও string_view, পর্ব ৩১ · map ও unordered_map, পর্ব ৩৩ · STL algorithm.

সমস্যা ২ · বাক্যের শব্দগুলোর ক্রম উল্টানো (সহজ)

প্রশ্ন: “the sky is blue” থেকে “blue is sky the” বানান। শুরু, শেষ বা মাঝের বাড়তি space বাদ যাবে, শব্দের মাঝে থাকবে ঠিক একটি space.

জিজ্ঞেস করে নিন: space ছাড়া অন্য whitespace (tab) আছে? নতুন string ফেরত দেব, নাকি in-place বদলাব? খালি বা শুধু space থাকা ইনপুটে কী ফেরত দেব?

পদ্ধতি ও জটিলতা: std::istringstream দিয়ে শব্দগুলো আলাদা করুন (>> নিজেই whitespace বাদ দেয়), vector-এ রাখুন, std::ranges::reverse করুন, তারপর জোড়া দিন। সময় O(n), মেমরি O(n).

#include <algorithm>
#include <print>
#include <sstream>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

std::string reverse_words(std::string_view s) {
    std::istringstream in{std::string{s}};
    std::vector<std::string> words;
    for (std::string w; in >> w;) words.push_back(std::move(w));
    std::ranges::reverse(words);
    std::string out;
    for (const auto& w : words) {
        if (!out.empty()) out += ' ';
        out += w;
    }
    return out;
}

int main() {
    for (std::string_view s : {"the sky is blue", "  hello   world  ", "single", "   "})
        std::println("[{}]", reverse_words(s));
}

সমস্যা ৩ · Anagram যাচাই, আর group anagrams (সহজ → মাঝারি)

প্রশ্ন: (ক) দুটি শব্দ পরস্পরের anagram কি না বলুন — “listen” আর “silent” হ্যাঁ। (খ) একগুচ্ছ শব্দকে anagram-দলে ভাগ করুন।

জিজ্ঞেস করে নিন: শুধু ছোট হাতের ইংরেজি অক্ষর, নাকি যেকোনো byte? বড়-ছোট হাতের পার্থক্য ধরব? দলগুলোর ক্রম কি গুরুত্বপূর্ণ?

পদ্ধতি ও জটিলতা: (ক) দুই রকম: দুটোই sort করে তুলনা — O(n log n); অথবা প্রতিটি অক্ষর গোনা — O(n) সময়, ২৫৬ ঘরের নির্দিষ্ট মেমরি। (খ) প্রতিটি শব্দের অক্ষর সাজালে একটি “পরিচয়” (key) পাওয়া যায় — “eat”, “tea”, “ate” সবার key “aet”. key থেকে শব্দ-তালিকার map বানালেই দল হয়ে যায়। k দৈর্ঘ্যের n টি শব্দে সময় O(n · k log k).

#include <algorithm>
#include <array>
#include <map>
#include <print>
#include <string>
#include <string_view>
#include <vector>

bool is_anagram(std::string_view a, std::string_view b) {
    if (a.size() != b.size()) return false;
    std::array<int, 256> count{};
    for (unsigned char c : a) ++count[c];
    for (unsigned char c : b)
        if (--count[c] < 0) return false;
    return true;
}

std::vector<std::vector<std::string>> group_anagrams(const std::vector<std::string>& words) {
    std::map<std::string, std::vector<std::string>> groups;  // sorted letters -> words
    for (const auto& w : words) {
        std::string key = w;
        std::ranges::sort(key);
        groups[key].push_back(w);
    }
    std::vector<std::vector<std::string>> out;
    for (auto& entry : groups) out.push_back(std::move(entry.second));
    return out;
}

int main() {
    std::println("{} {} {}", is_anagram("listen", "silent"), is_anagram("rat", "car"), is_anagram("", ""));
    for (const auto& g : group_anagrams({"eat", "tea", "tan", "ate", "nat", "bat"})) std::println("{}", g);
}

সমস্যা ৪ · পুনরাবৃত্তিহীন দীর্ঘতম substring (মাঝারি)

প্রশ্ন: একটি string-এর এমন দীর্ঘতম টানা অংশের দৈর্ঘ্য বের করুন, যেখানে কোনো অক্ষর দুবার নেই। “abcabcbb” → 3 (“abc”), “pwwkew” → 3 (“wke”).

জিজ্ঞেস করে নিন: substring (টানা অংশ) নাকি subsequence (মাঝে বাদ দেওয়া চলে)? অক্ষরের সেট কত বড় — ASCII নাকি Unicode? খালি string-এ উত্তর 0 তো?

পদ্ধতি ও জটিলতা: Brute force: প্রতিটি শুরু থেকে যতদূর যাওয়া যায় — O(n²) বা তার বেশি। উন্নত: sliding window. একটি জানালা [left, right] ডানে বাড়ান; নতুন অক্ষরটি জানালার ভেতরে আগে থাকলে left-কে তার আগের অবস্থানের ঠিক পরে সরান। প্রতিটি অক্ষরের শেষ দেখা index একটি অ্যারেতে রাখুন। সময় O(n), মেমরি O(অক্ষরের সেট). নিচে “abba” দিয়ে ধাপে ধাপে দেখুন — এখানে একটি সূক্ষ্ম ফাঁদ আছে:

1ptrdiff_t longest_unique(string_view s) {2    last.fill(-1);3    ptrdiff_t best = 0, left = 0;4    for (right = 0; right < ssize(s); ++right) {5        c = s[right];6        left = max(left, last[c] + 1);7        last[c] = right;8        best = max(best, right - left + 1);9    }10    return best;11}

#include <algorithm>
#include <array>
#include <print>
#include <string_view>

// Length of the longest substring with no repeated character (sliding window).
std::ptrdiff_t longest_unique(std::string_view s) {
    std::array<std::ptrdiff_t, 256> last;          // last index of each byte
    last.fill(-1);
    std::ptrdiff_t best = 0, left = 0;             // window is s[left..right]
    for (std::ptrdiff_t right = 0; right < std::ssize(s); ++right) {
        const auto c = static_cast<unsigned char>(s[right]);
        left = std::max(left, last[c] + 1);        // jump past the previous copy
        last[c] = right;
        best = std::max(best, right - left + 1);
    }
    return best;
}

int main() {
    for (std::string_view s : {"abcabcbb", "bbbbb", "pwwkew", "", "abba"})
        std::println("\"{}\" -> {}", s, longest_unique(s));
}

সমস্যা ৫ · প্রথম অপুনরাবৃত্ত অক্ষর (সহজ)

প্রশ্ন: string-এর প্রথম যে অক্ষর ঠিক একবারই আছে, সেটি বের করুন। “swiss” → 'w', “aabb” → নেই।

পদ্ধতি ও জটিলতা: দুবার পার হোন — প্রথমবার গুনুন, দ্বিতীয়বার মূল ক্রমে প্রথম যার গণনা ১, সেটি ফেরত দিন। সময় O(n), মেমরি নির্দিষ্ট (২৫৬ ঘর)। একবার পার হয়ে map-এর ক্রমে খুঁজলে ভুল হয়: unordered_map-এর কোনো নির্দিষ্ট ক্রম নেই।

std::optional<char> first_unique(std::string_view s) {
    std::array<int, 256> count{};
    for (unsigned char c : s) ++count[c];
    for (char c : s)
        if (count[static_cast<unsigned char>(c)] == 1) return c;
    return std::nullopt;                       // "aabb": every character repeats
}

Edge case ও ফলো-আপ: খালি string → nullopt; “leetcode” → 'l'. ফলো-আপে প্রায়ই আসে: অক্ষরগুলো একটি stream-এ একটি একটি করে আসছে, প্রতিবার “এ পর্যন্ত প্রথম অপুনরাবৃত্ত” বলতে হবে। তখন গণনার সাথে একটি queue রাখুন, আর সামনের অক্ষরের গণনা ১-এর বেশি হলে সেটি ফেলে দিন — প্রতি অক্ষরে গড়ে O(1).

৪ · স্ট্যাক, কিউ ও লিংকড লিস্ট

এই গোত্রে দুটি জিনিস একসাথে যাচাই হয়: ঠিক data structure চেনা, আর C++-এ মালিকানা (ownership) পরিষ্কার রাখা। রিভিশনের জন্য: পর্ব ১৭ · RAII ও smart pointer, পর্ব ৩০ · sequence container, পর্ব ৩৬ · move semantics.

সমস্যা ৬ · বন্ধনী ঠিকঠাক মেলানো কি না (সহজ)

প্রশ্ন: (), [], {} মেশানো একটি string-এ প্রতিটি খোলা বন্ধনী কি সঠিক ক্রমে সঠিক ধরনের বন্ধনী দিয়ে বন্ধ হয়েছে?

জিজ্ঞেস করে নিন: অন্য অক্ষর থাকবে কি (যেমন একটি গাণিতিক রাশি)? থাকলে উপেক্ষা করব তো? খালি string-কে balanced ধরব?

পদ্ধতি ও জটিলতা: শেষে যে খুলেছে, তাকেই আগে বন্ধ হতে হবে — এটাই LIFO, অর্থাৎ std::stack. খোলা বন্ধনী push; বন্ধ বন্ধনী এলে top-এর সাথে মিলিয়ে pop. সময় O(n), মেমরি O(n).

#include <print>
#include <stack>
#include <string_view>

bool is_balanced(std::string_view s) {
    std::stack<char> open;
    for (const char c : s) {
        switch (c) {
            case '(': case '[': case '{': open.push(c); break;
            case ')': case ']': case '}': {
                const char want = c == ')' ? '(' : c == ']' ? '[' : '{';
                if (open.empty() || open.top() != want) return false;
                open.pop();
                break;
            }
            default: break;                        // ignore every other character
        }
    }
    return open.empty();                           // a leftover opener = unbalanced
}

int main() {
    for (std::string_view s : {"()[]{}", "([)]", "{[()]}", "((", ")(", "", "f(a[i]) {}"})
        std::println("\"{}\" -> {}", s, is_balanced(s));
}

সমস্যা ৭ · Min-stack — সবসময় O(1)-এ সর্বনিম্ন (মাঝারি)

প্রশ্ন: একটি stack class ডিজাইন করুন, যেখানে push, pop, top আর min — চারটিই O(1).

জিজ্ঞেস করে নিন: খালি stack-এ pop বা min ডাকলে কী হবে — exception, নাকি precondition (ডাকা নিষেধ)? টাইপ কি শুধু int, নাকি template?

পদ্ধতি ও জটিলতা: প্রতিটি উপাদানের পাশে “এখন পর্যন্ত নিচের সবার সর্বনিম্ন” জমা রাখুন। pop করলে সেই তথ্যও নিজে থেকে চলে যায়, আগের সর্বনিম্ন ফিরে আসে। সব কাজ O(1), মেমরি ২n.

#include <algorithm>
#include <print>
#include <stdexcept>
#include <vector>

class MinStack {
public:
    void push(int x) {
        const int m = data_.empty() ? x : std::min(x, data_.back().min);
        data_.push_back({x, m});
    }
    void pop() { check(); data_.pop_back(); }
    [[nodiscard]] int top() const { check(); return data_.back().value; }
    [[nodiscard]] int min() const { check(); return data_.back().min; }
    [[nodiscard]] bool empty() const noexcept { return data_.empty(); }
private:
    struct Entry { int value; int min; };          // min of this entry and all below it
    void check() const { if (data_.empty()) throw std::out_of_range("MinStack is empty"); }
    std::vector<Entry> data_;
};

int main() {
    MinStack s;
    for (int x : {5, 3, 7, 3, 1}) { s.push(x); std::print("{} ", s.min()); }
    std::println("");
    while (!s.empty()) { std::print("{}/{} ", s.top(), s.min()); s.pop(); }
    std::println("");
    try { s.pop(); } catch (const std::out_of_range& e) { std::println("error: {}", e.what()); }
}

সমস্যা ৮ · unique_ptr দিয়ে লিংকড লিস্ট উল্টানো (সহজ, কিন্তু খুব জনপ্রিয়)

প্রশ্ন: একমুখী linked list-এর head দেওয়া আছে। নতুন node না বানিয়ে লিস্টটি উল্টে নতুন head ফেরত দিন।

জিজ্ঞেস করে নিন: node-এর মালিক কে — raw pointer, নাকি std::unique_ptr? খালি লিস্ট আসতে পারে? (আসতে পারে।)

পদ্ধতি ও জটিলতা: C-র মতোই তিনটি হাত — উল্টানো অংশ (prev), বর্তমান node (head), বাকি অংশ (rest). পার্থক্য হলো, প্রতিটি “তীর ঘোরানো” এখানে মালিকানার হস্তান্তর, তাই প্রতিটি লাইনে std::move. সময় O(n), মেমরি O(1).

#include <initializer_list>
#include <iterator>
#include <memory>
#include <print>
#include <utility>

struct Node {
    int val;
    std::unique_ptr<Node> next;                    // a node owns the rest of the list
};

std::unique_ptr<Node> reverse(std::unique_ptr<Node> head) {
    std::unique_ptr<Node> prev;                    // reversed part, starts empty
    while (head) {
        auto rest = std::move(head->next);         // 1. hold on to the rest
        head->next = std::move(prev);              // 2. turn the arrow around
        prev = std::move(head);                    // 3. grow the reversed part
        head = std::move(rest);                    // 4. step forward
    }
    return prev;
}

std::unique_ptr<Node> make_list(std::initializer_list<int> vals) {
    std::unique_ptr<Node> head;
    for (auto it = std::rbegin(vals); it != std::rend(vals); ++it)
        head = std::make_unique<Node>(*it, std::move(head));
    return head;
}

void print(const Node* p) {
    for (; p; p = p->next.get()) std::print("{} ", p->val);
    std::println("|");
}

int main() {
    print(reverse(make_list({1, 2, 3, 4, 5})).get());
    print(reverse(nullptr).get());
    print(reverse(make_list({9})).get());
}

৫ · ট্রি, হিপ, বাইনারি সার্চ ও DP

এই অংশের সমস্যাগুলোতে কৌশল চেনাই আসল: “সাজানো” শুনলে binary search, “স্তরে স্তরে” শুনলে queue, “সবচেয়ে বড় k টি” শুনলে heap, “কত উপায়ে / সর্বনিম্ন কত” শুনলে DP. রিভিশনের জন্য: পর্ব ১৭, পর্ব ৩০ · sequence container ও adaptor, পর্ব ৩৩ · STL algorithm, পর্ব ৩৪ · lambda, পর্ব ৫০ · কনটেস্টের প্যাটার্ন।

সমস্যা ৯ · BST-তে insert আর inorder traversal (সহজ)

প্রশ্ন: একটি binary search tree-তে key যোগ করুন, তারপর সব key সাজানো ক্রমে বের করুন।

জিজ্ঞেস করে নিন: ডুপ্লিকেট key কোথায় যাবে — বাদ, নাকি ডানে? tree কি balanced রাখতে হবে? (না হলে খারাপ ক্ষেত্রে উচ্চতা n.)

পদ্ধতি ও জটিলতা: insert: root থেকে ছোট হলে বাঁয়ে, নইলে ডানে, খালি জায়গা পেলে সেখানে নতুন node. Inorder traversal (বাঁ → root → ডান) BST-তে সবসময় সাজানো ক্রম দেয়। insert O(h), traversal O(n); h হলো উচ্চতা — balanced হলে log n, সাজানো ইনপুটে n.

#include <memory>
#include <print>
#include <vector>

struct Tree {
    explicit Tree(int k) : key(k) {}
    int key;
    std::unique_ptr<Tree> left, right;
};

void insert(std::unique_ptr<Tree>& root, int key) {      // iterative: no deep recursion
    auto* slot = &root;
    while (*slot) slot = key < (*slot)->key ? &(*slot)->left : &(*slot)->right;
    *slot = std::make_unique<Tree>(key);
}

void inorder(const Tree* t, std::vector<int>& out) {     // left, root, right = sorted
    if (!t) return;
    inorder(t->left.get(), out);
    out.push_back(t->key);
    inorder(t->right.get(), out);
}

int main() {
    std::unique_ptr<Tree> root;
    for (int k : {50, 30, 70, 20, 40, 60, 80, 35}) insert(root, k);
    std::vector<int> sorted;
    inorder(root.get(), sorted);
    std::println("inorder: {}", sorted);
    std::vector<int> none;
    inorder(nullptr, none);
    std::println("empty:   {}", none);
}

সমস্যা ১০ · Level-order traversal — স্তরে স্তরে BFS (মাঝারি)

প্রশ্ন: binary tree-এর key-গুলো স্তর ধরে ফেরত দিন: [[50], [30, 70], [20, 40, 60, 80], [35]].

পদ্ধতি ও জটিলতা: Level-order মানে BFS: যে node আগে দেখা, তার সন্তানদের আগে দেখা — FIFO, অর্থাৎ std::queue. স্তর আলাদা করার কৌশল: প্রতিটি স্তর শুরুর সময় queue-তে ঠিক কয়টি node আছে গুনে রাখুন, ঠিক ততগুলোই বের করুন। সময় O(n), মেমরি O(সবচেয়ে চওড়া স্তর).

std::vector<std::vector<int>> level_order(const Tree* root) {
    std::vector<std::vector<int>> levels;
    std::queue<const Tree*> q;
    if (root) q.push(root);
    while (!q.empty()) {
        auto& level = levels.emplace_back();            // C++17: returns a reference
        for (auto n = q.size(); n > 0; --n) {           // exactly one level per pass
            const Tree* t = q.front();
            q.pop();
            level.push_back(t->key);
            if (t->left) q.push(t->left.get());
            if (t->right) q.push(t->right.get());
        }
    }
    return levels;
}

Edge case ও ফলো-আপ: খালি tree → খালি ফল (প্রথম if না থাকলে nullptr queue-তে ঢুকত)। queue-তে raw const Tree* রাখা ঠিক আছে, কারণ মালিক tree নিজেই, আর traversal চলাকালীন tree বদলাচ্ছে না। ফলো-আপ: zigzag ক্রম (প্রতি বিজোড় স্তর উল্টে দিন — std::ranges::reverse); প্রতিটি স্তরের ডানদিকের node (“right view”); tree-এর সর্বনিম্ন গভীরতা — BFS প্রথম পাতায় পৌঁছেই থামতে পারে, DFS পারে না।

সমস্যা ১১ · ঘোরানো সাজানো অ্যারেতে সার্চ (মাঝারি)

প্রশ্ন: একটি সাজানো অ্যারে কোনো অজানা বিন্দুতে ঘোরানো হয়েছে, যেমন [4, 5, 6, 7, 0, 1, 2]. O(log n)-এ target-এর index বের করুন, না থাকলে -1.

জিজ্ঞেস করে নিন: মানগুলো কি ভিন্ন? (ডুপ্লিকেট থাকলে খারাপ ক্ষেত্রে O(n) লাগে।) খালি অ্যারে আসতে পারে?

পদ্ধতি: Binary search-এর রূপভেদ। যেকোনো mid-এ দুই অর্ধেকের অন্তত একটি পুরোপুরি সাজানো। সাজানো অর্ধেকের সীমার ভেতরে target থাকলে সেদিকে যান, নইলে অন্যদিকে। প্রতি ধাপে খোঁজার জায়গা অর্ধেক — O(log n), মেমরি O(1).

#include <print>
#include <vector>

// Index of target in a rotated sorted array of distinct values, or -1.
int search_rotated(const std::vector<int>& a, int target) {
    int lo = 0, hi = static_cast<int>(a.size()) - 1;
    while (lo <= hi) {
        const int mid = lo + (hi - lo) / 2;
        if (a[mid] == target) return mid;
        if (a[lo] <= a[mid]) {                         // left half is sorted
            if (a[lo] <= target && target < a[mid]) hi = mid - 1;
            else lo = mid + 1;
        } else {                                       // right half is sorted
            if (a[mid] < target && target <= a[hi]) lo = mid + 1;
            else hi = mid - 1;
        }
    }
    return -1;
}

int main() {
    const std::vector<int> a{4, 5, 6, 7, 0, 1, 2};
    for (int t : {0, 4, 2, 7, 3}) std::print("{} ", search_rotated(a, t));
    std::println("| {} {}", search_rotated({}, 1), search_rotated({1}, 1));
}

সমস্যা ১২ · k-তম বৃহত্তম সংখ্যা (মাঝারি)

প্রশ্ন: একটি অসাজানো vector-এর k-তম বৃহত্তম মান বের করুন। [3, 2, 1, 5, 6, 4], k = 2 → 5.

পদ্ধতি ও জটিলতা: তিনটি উত্তর, তিনটি trade-off — তিনটিই বলুন: (ক) পুরো sort: O(n log n). (খ) k আকারের min-heap: প্রতিটি মান ঢোকান, আকার k ছাড়ালে সবচেয়ে ছোটটি ফেলুন; শেষে top-ই উত্তর — O(n log k) সময়, O(k) মেমরি, আর ডেটা stream-এ এলেও চলে। (গ) std::nth_element: গড়ে O(n), কিন্তু ইনপুট বদলে দেয়।

int kth_largest(const std::vector<int>& a, int k) {       // needs 1 <= k <= a.size()
    std::priority_queue<int, std::vector<int>, std::greater<>> heap;   // min-heap
    for (int x : a) {
        heap.push(x);
        if (std::ssize(heap) > k) heap.pop();              // keep only the k largest
    }
    return heap.top();
}
// Alternative, average O(n), reorders a copy:
//   std::ranges::nth_element(v, v.begin() + (k - 1), std::greater<>{});  return v[k - 1];

Edge case ও ফলো-আপ: std::priority_queue ডিফল্টে max-heap — top-এ সবচেয়ে বড়; std::greater<> দিলে min-heap. এটা গুলিয়ে ফেলা খুব সাধারণ ভুল। k অবৈধ হলে (0, বা n-এর বেশি) খালি heap-এ top() undefined behavior — precondition লিখে রাখুন বা std::optional ফেরত দিন। ডুপ্লিকেট গোনা হবে কি না ([3, 3, 2], k = 2 → 3 নাকি 2?) জিজ্ঞেস করুন। ফলো-আপ: সবচেয়ে ঘন ঘন আসা k টি শব্দ (map দিয়ে গোনা + heap).

সমস্যা ১৩ · সিঁড়ি বেয়ে ওঠা ও কয়েন চেঞ্জ (মাঝারি)

প্রশ্ন: (ক) n ধাপের সিঁড়িতে একবারে ১ বা ২ ধাপ উঠা যায় — কত উপায়ে উপরে পৌঁছানো যায়? (খ) নির্দিষ্ট মানের কয়েন (প্রতিটি অসীম সংখ্যক) দিয়ে একটি টাকার পরিমাণ বানাতে সবচেয়ে কম কয়টি কয়েন লাগে?

পদ্ধতি: দুটোই dynamic programming. (ক) শেষ পদক্ষেপ ১ বা ২ ধাপের, তাই ways(n) = ways(n-1) + ways(n-2) — Fibonacci; শুধু শেষ দুটি মান রাখলে O(n) সময়, O(1) মেমরি। (খ) dp[x] = x বানানোর সর্বনিম্ন কয়েন; প্রতিটি কয়েন c-এর জন্য dp[x - c] + 1 চেষ্টা। সময় O(amount · কয়েনের সংখ্যা)। সরাসরি recursion করলে একই উপসমস্যা বহুবার হিসাব হয় — exponential; ফল জমিয়ে রাখা (memoization) বা নিচ থেকে টেবিল ভরাই সমাধান।

#include <print>
#include <vector>

long long climb_ways(int n) {                      // 1 or 2 steps at a time
    long long a = 1, b = 1;                        // ways(0), ways(1)
    for (int i = 2; i <= n; ++i) {
        const long long c = a + b;                 // ways(i) = ways(i-1) + ways(i-2)
        a = b;
        b = c;
    }
    return b;
}

// Fewest coins that make `amount`, or -1 if impossible (bottom-up DP).
int min_coins(const std::vector<int>& coins, int amount) {
    const int INF = amount + 1;                    // larger than any real answer
    std::vector<int> dp(amount + 1, INF);
    dp[0] = 0;
    for (int x = 1; x <= amount; ++x)
        for (int c : coins)
            if (c <= x && dp[x - c] + 1 < dp[x]) dp[x] = dp[x - c] + 1;
    return dp[amount] == INF ? -1 : dp[amount];
}

int main() {
    std::println("stairs: {} {} {} {}", climb_ways(1), climb_ways(2), climb_ways(5), climb_ways(50));
    std::println("coins:  {} {} {} {}", min_coins({1, 3, 4}, 6), min_coins({2}, 3),
                 min_coins({1, 2, 5}, 11), min_coins({7}, 0));
}

৬ · C++ ডিজাইন সমস্যা — LRU cache, Rule of Five, thread-safe queue

এখানে অ্যালগরিদম ছোট, কিন্তু ভাষার জ্ঞান গভীরভাবে যাচাই হয়: container-এর জটিলতা, iterator কখন বৈধ থাকে, মালিকানা, exception-safety আর thread. রিভিশনের জন্য: পর্ব ২০, পর্ব ২১, পর্ব ২২ · Rule of 0/3/5, পর্ব ৩২ · iterator, পর্ব ৩৬, পর্ব ৪৫ · thread ও mutex, পর্ব ৪৬ · atomics.

সমস্যা ১৪ · LRU cache — get আর put দুটোই O(1) (মাঝারি → কঠিন)

প্রশ্ন: নির্দিষ্ট ধারণক্ষমতার একটি cache বানান। get(key) মান দেয় (না থাকলে “নেই”); put(key, value) যোগ বা বদল করে। জায়গা ভরে গেলে সবচেয়ে দীর্ঘ সময় ব্যবহার না হওয়া (least recently used) key বাদ যাবে।

জিজ্ঞেস করে নিন: get-ও কি “ব্যবহার” ধরা হবে? (হ্যাঁ।) ধারণক্ষমতা 0 হলে? একাধিক thread থেকে ডাকা হবে কি?

পদ্ধতি: দুটি চাহিদা — key দিয়ে দ্রুত খোঁজা (hash map), আর ব্যবহারের ক্রম রাখা, যেখানে যেকোনো উপাদান O(1)-এ সামনে আনা যায় (doubly linked list). তাই std::list + std::unordered_map<key, list::iterator>. মূল কৌশল splice: কোনো node কপি বা নতুন করে না বানিয়ে লিস্টের সামনে সরানো — O(1), আর std::list-এর iterator এতে অবৈধ হয় না (iterator invalidation-এর নিয়ম, পর্ব ৩২)।

#include <list>
#include <optional>
#include <print>
#include <unordered_map>
#include <utility>

class LRUCache {
public:
    explicit LRUCache(std::size_t capacity) : cap_(capacity) {}
    std::optional<int> get(int key) {
        auto it = pos_.find(key);
        if (it == pos_.end()) return std::nullopt;
        items_.splice(items_.begin(), items_, it->second);   // move to front, O(1)
        return it->second->second;
    }
    void put(int key, int value) {
        if (cap_ == 0) return;
        if (auto it = pos_.find(key); it != pos_.end()) {
            it->second->second = value;
            items_.splice(items_.begin(), items_, it->second);
            return;
        }
        if (items_.size() == cap_) {                          // evict the least recent
            pos_.erase(items_.back().first);
            items_.pop_back();
        }
        items_.emplace_front(key, value);
        pos_[key] = items_.begin();
    }
private:
    using Item = std::pair<int, int>;                         // (key, value)
    std::size_t cap_;
    std::list<Item> items_;                                   // front = most recent
    std::unordered_map<int, std::list<Item>::iterator> pos_;  // key -> list node
};

int main() {
    LRUCache c(2);
    auto show = [&c](int key) { std::print("{} ", c.get(key).value_or(-1)); };
    c.put(1, 10); c.put(2, 20);
    show(1);                                       // 10; key 1 is now most recent
    c.put(3, 30);                                  // evicts key 2
    show(2); show(3);
    c.put(1, 11); c.put(4, 40);                    // evicts key 3
    show(1); show(3); show(4);
    std::println("");
}

সমস্যা ১৫ · একটি Rule-of-Five টাইপ: নিজের মেমরি রাখা Buffer (মাঝারি)

প্রশ্ন: একটি class লিখুন যা heap-এ n টি int রাখে। copy করলে আলাদা স্বাধীন কপি হবে, move করলে শুধু pointer সরবে, কোথাও leak বা double delete হবে না।

জিজ্ঞেস করে নিন: বাস্তবে কি std::vector<int> ব্যবহার করা যায়? (প্রায় সবসময় হ্যাঁ — তখন Rule of Zero, কোনো বিশেষ ফাংশন লিখতেই হয় না। ইন্টারভিউয়ার এটা শুনতে চান, তারপর বলবেন “তবু নিজে লিখে দেখান।”)

পদ্ধতি: Rule of Five: destructor, copy constructor, copy assignment, move constructor, move assignment — একটি লিখলে সাধারণত পাঁচটিই ভাবতে হয়। এখানে copy-and-swap: assignment প্যারামিটার মান দিয়ে নেয়, তাই একটি ফাংশনই copy ও move দুই assignment-এর কাজ করে, আর self-assignment ও exception-safety নিজে থেকেই ঠিক থাকে।

#include <algorithm>
#include <cstddef>
#include <print>
#include <utility>

class Buffer {
public:
    explicit Buffer(std::size_t n) : size_(n), data_(n ? new int[n]{} : nullptr) {}
    ~Buffer() { delete[] data_; }                                  // 1. destructor
    Buffer(const Buffer& o) : Buffer(o.size_) {                    // 2. copy constructor
        std::copy_n(o.data_, size_, data_);
    }
    Buffer(Buffer&& o) noexcept                                    // 3. move constructor
        : size_(std::exchange(o.size_, 0)), data_(std::exchange(o.data_, nullptr)) {}
    Buffer& operator=(Buffer o) noexcept {                         // 4 + 5. copy-and-swap
        swap(o);
        return *this;
    }
    void swap(Buffer& o) noexcept { std::swap(size_, o.size_); std::swap(data_, o.data_); }
    int& operator[](std::size_t i) { return data_[i]; }
    [[nodiscard]] std::size_t size() const noexcept { return size_; }
private:
    std::size_t size_;
    int* data_;
};

int main() {
    Buffer a(3);
    a[0] = 7;
    Buffer b = a;                  // deep copy
    b[0] = 99;
    Buffer c = std::move(a);       // steals the pointer
    Buffer d(1);
    d = c;                         // copy-assign through copy-and-swap
    std::println("a.size={} b[0]={} c[0]={} d.size={} d[0]={}", a.size(), b[0], c[0], d.size(), d[0]);
}

সমস্যা ১৬ · Thread-safe queue আর counter (মাঝারি → কঠিন)

প্রশ্ন: একাধিক producer thread কাজ রাখবে, consumer thread কাজ তুলবে। queue খালি হলে consumer অপেক্ষা করবে — CPU নষ্ট না করে। আর একটি সহজ রূপ: কয়েকটি thread মিলে একটি counter বাড়াবে, শেষে মান ঠিক থাকতে হবে।

পদ্ধতি: queue-এর প্রতিটি ব্যবহার একটি mutex-এর তালার ভেতরে; অপেক্ষার জন্য std::condition_variable, যা predicate-সহ wait-এ spurious wakeup-ও সামলায়। Counter-এর জন্য mutex লাগে না — std::atomic<int>-এর fetch_add একটি অবিভাজ্য কাজ।

template <typename T>
class SafeQueue {
public:
    void push(T value) {
        {
            std::lock_guard lock(m_);              // C++17: template argument deduced
            q_.push(std::move(value));
        }                                          // unlock before notifying
        cv_.notify_one();
    }
    T pop() {                                      // blocks until an item exists
        std::unique_lock lock(m_);
        cv_.wait(lock, [this] { return !q_.empty(); });
        T value = std::move(q_.front());
        q_.pop();
        return value;
    }
private:
    std::mutex m_;
    std::condition_variable cv_;
    std::queue<T> q_;
};

std::atomic<int> counter{0};                       // thread-safe counter, no mutex
// in each thread:  counter.fetch_add(1, std::memory_order_relaxed);

যা নিজে থেকে বলবেন: std::lock_guard আর std::unique_lock দুটোই RAII — exception হলেও তালা খোলে। wait-এর জন্য unique_lock লাগে, কারণ অপেক্ষার সময় তালা খুলে আবার নিতে হয়। আলাদা empty() আর front() দুটি public ফাংশন দিলে দুটি ডাকের মাঝে অন্য thread ঢুকে পড়তে পারে — তাই “দেখা আর তোলা” একটি ফাংশনেই। সাধারণ int-এ counter++ একাধিক thread থেকে করা data race, অর্থাৎ undefined behavior; volatile এর সমাধান নয়। ফলো-আপ: সীমিত আকারের queue (দ্বিতীয় condition variable, “ভরা থাকলে producer অপেক্ষা করবে”); বন্ধ করার ব্যবস্থা (close() বা std::stop_token, পর্ব ৪৫); pop-এ timeout দিয়ে std::optional<T> ফেরত।

৭ · ভাবনার প্রশ্ন — C++ ইন্টারভিউর গভীর আলোচনা

কোড লেখার পর ইন্টারভিউয়ার প্রায়ই জিজ্ঞেস করেন, “এটা কেন এভাবে লিখলেন?” নিচের প্রশ্নগুলো সেই আলোচনার প্রস্তুতি। উত্তরের ভালো কাঠামো: এক লাইনে সারকথা → কারণ → একটি ফাঁদ বা বাস্তব উদাহরণ। প্রতিটি আগে নিজে মুখে উত্তর দিন, তারপর খুলুন। রিভিশনের জন্য: পর্ব ১০, পর্ব ৩১, পর্ব ৩৬, পর্ব ৪৩, পর্ব ৪৮, পর্ব ৪৯।

৮ · কথা বলা, ক্যাপস্টোন ব্যাখ্যা আর AI

একই সমাধান জানা দুজন প্রার্থীর একজন নির্বাচিত হন, অন্যজন হন না — প্রায়ই পার্থক্যটা যোগাযোগে। এই দক্ষতাও অনুশীলনে বাড়ে, ঠিক কোডের মতো।

ইন্টারভিউর ঘরে পাঁচটি অভ্যাস

• জোরে ভাবুন (think aloud): “প্রথমে brute force ভাবছি… এটা O(n²), n যদি ১০^৫ হয় তাহলে ধীর… তাই unordered_map ভাবছি।” চুপ করে দুই মিনিট ভাবার চেয়ে অর্ধেক-গোছানো ভাবনা বলাও ভালো — ইন্টারভিউয়ার পথ দেখে সাহায্য করতে পারেন।
• প্রশ্ন করুন, ধরে নেবেন না: “ইনপুট কি সাজানো?”, “খালি vector আসতে পারে?” — এগুলো দুর্বলতা নয়, পেশাদারিত্ব।
• Hint-কে উপহার ভাবুন: ইন্টারভিউয়ার “যদি অ্যারেটা সাজানো থাকত?” বললে সেটা একটা দরজা। ধন্যবাদ দিয়ে ধরুন, আর বলুন hint থেকে কী বুঝলেন।
• ভুল স্বীকার করুন, দ্রুত: dry run-এ নিজের বাগ ধরলে সাথে সাথে বলুন। নিজের ভুল নিজে ধরা ইন্টারভিউতে খুব ইতিবাচক সংকেত।
• না জানলে সৎ থাকুন: “std::pmr নিয়ে কাজ করিনি, তবে যতটুকু জানি…” — বানিয়ে বলা অভিজ্ঞ ইন্টারভিউয়ার সাথে সাথে ধরে ফেলেন।

নিজের ক্যাপস্টোন প্রজেক্ট কীভাবে ব্যাখ্যা করবেন

“আপনার একটি প্রজেক্টের কথা বলুন” — এই প্রশ্নটি প্রায় নিশ্চিত। পর্ব ৫১-এর ক্যাপস্টোন (বা পর্ব ১৯-এর CLI টুল) এখানে আপনার সবচেয়ে বড় সম্পদ, কারণ এটি আপনি নিজে বানিয়েছেন। পাঁচ মিনিটের একটি কাঠামো তৈরি রাখুন:

1. সমস্যা ও ব্যবহারকারী (৩০ সেকেন্ড): প্রজেক্টটি কী করে, কার জন্য।
2. কাঠামো (১ মিনিট): প্রধান class বা module-গুলো, কে কার মালিক, ডেটা কোথা থেকে কোথায় যায়। খাতায় তিন-চারটি বাক্স এঁকে দেখাতে পারলে আরও ভালো।
3. দুটি সিদ্ধান্ত ও তার কারণ (২ মিনিট): “এখানে std::map নিয়েছি, কারণ রিপোর্টে সাজানো ক্রম লাগত”; “ফাইল হ্যান্ডেল RAII class-এ রেখেছি, যাতে exception হলেও বন্ধ হয়।” trade-off বলুন — কী ছেড়ে দিয়েছেন।
4. একটি কঠিন বাগ (১ মিনিট): লক্ষণ, কীভাবে খুঁজলেন (sanitizer, debugger, test), আসল কারণ, কী শিখলেন।
5. পরের উন্নতি (৩০ সেকেন্ড): আরও সময় পেলে কী বদলাতেন — এটা দেখায় আপনি নিজের কাজের দুর্বলতা চেনেন।

সততার নিয়ম: যে অংশ টিউটোরিয়াল, বন্ধু বা AI-এর সাহায্যে লিখেছেন, সেটা লুকাবেন না — বলুন কোন অংশ নিজে বুঝে বদলেছেন। ইন্টারভিউয়ার প্রায়ই প্রজেক্টের যেকোনো লাইন দেখিয়ে জিজ্ঞেস করেন, “এটা কেন?” যে কোড আপনি ব্যাখ্যা করতে পারেন না, তা আপনার পক্ষে নয়, বিপক্ষে কাজ করে। “দলগত প্রজেক্টে আমার অংশ ছিল…” — নিজের অবদান ঠিক যতটুকু, ততটুকুই বলুন।

আচরণগত প্রশ্নে STAR কাঠামো

“এমন একটা সময়ের কথা বলুন যখন…” — এ ধরনের প্রশ্নে STAR কাঠামোয় উত্তর গোছান: Situation (পরিস্থিতি), Task (আপনার দায়িত্ব), Action (আপনি নিজে কী করলেন), Result (ফল, আর কী শিখলেন)। ৪–৫টি সত্যি গল্প আগে থেকে তৈরি রাখুন: একটি কঠিন বাগ, একটি দলগত মতবিরোধ, একটি ব্যর্থতা ও তা থেকে শেখা, নিজে থেকে নেওয়া একটি উদ্যোগ। বানানো গল্প নয় — পরের প্রশ্নেই ফাঁক বেরিয়ে যায়।

AI-এর যুগে ইন্টারভিউ: নিয়ম আর সততা

কেন মুখস্থ নয়, বোঝা? জনপ্রিয় সমস্যার সমাধান অনলাইনে আছে, ইন্টারভিউয়ার তা জানেন। তাই আসল পরীক্ষা হয় ফলো-আপে: “এবার thread-safe করুন”, “ইনপুট stream-এ এলে?” মুখস্থ সমাধান এখানেই ভেঙে পড়ে। প্রস্তুতির সময় অবশ্য AI হতে পারে চমৎকার mock interview-এর সঙ্গী আর code review-এর সাহায্যকারী — শর্ত: উত্তর নয়, প্রশ্ন আর মূল্যায়ন চাইবেন।

নিজের লেখা সমাধান যাচাই করাতে চাইলে আলাদা prompt দিন: “এই C++ সমাধানের বাগ, অনাবৃত edge case আর জটিলতার ভুল খুঁজে দাও; ঠিক করা কোড লিখবে না, শুধু কোন লাইনে কী সমস্যা বলবে।” এতে ঠিক করার কাজটা আপনার হাতেই থাকে।

AI দিয়ে অনুশীলনের চেকলিস্ট

• সমাধান দেখার আগে নিজে অন্তত ২০ মিনিট চেষ্টা করেছি, আর খাতায় পদ্ধতি লিখেছি
• AI-এর বলা জটিলতা নিজে হিসাব করে মিলিয়েছি — AI প্রায়ই “গড়ে” আর “খারাপ ক্ষেত্রে” গুলিয়ে ফেলে
• AI-এর C++ কোড -Wall -Wextra আর sanitizer দিয়ে চালিয়েছি, নিজের edge case-এ পরীক্ষা করেছি
• AI-এর কোডে dangling reference, iterator invalidation বা অপ্রয়োজনীয় কপি আছে কি না নিজে খুঁজেছি
• একদিন পরে AI ছাড়া একই সমস্যা আবার শূন্য থেকে সমাধান করতে পেরেছি
• সমাধানটি অন্য কাউকে (বা নিজেকে, জোরে) পাঁচ মিনিটে ব্যাখ্যা করতে পারি

৯ · কোর্স সমাপ্তি — ৫৫টি পর্বের পরে আপনি কোথায়

এটি ৮টি মডিউল আর ৫৫টি পর্বের এই কোর্সের শেষ পর্ব। একবার পেছনে তাকান। পর্ব ১-এ প্রশ্ন ছিল, “C++ কেন?” পর্ব ৩-এ দেখেছিলেন একটি .cpp ফাইল কীভাবে প্রোগ্রাম হয়। আজ আপনি একটি LRU cache-এর জন্য ঠিক container বাছতে পারেন, move constructor-এ কেন noexcept লাগে বোঝাতে পারেন, আর একটি অচেনা সমস্যাকে সাত ধাপে ভেঙে সমাধান করতে পারেন। আন্তরিক অভিনন্দন — C++-এর মতো বিশাল একটি ভাষার পুরো পথ পার হওয়া সত্যিই বড় অর্জন।

এখন আপনি যা পারেন

• টাইপ, reference, pointer, lifetime আর মালিকানা দিয়ে মেমরির ভেতরের ছবিটা নিজের ভাষায় ব্যাখ্যা করতে।
• class, constructor-destructor, Rule of 0/3/5, inheritance আর polymorphism দিয়ে নিজের টাইপ ডিজাইন করতে।
• template, STL container, iterator, algorithm, lambda আর ranges দিয়ে কম কোডে নির্ভুল সমাধান লিখতে।
• move semantics, optional/variant/expected, constexpr, concepts — আধুনিক C++ বুঝে ব্যবহার করতে, আর undefined behavior চিনতে।
• ফাইল, thread, atomics, CMake, test আর profiler দিয়ে একটি বাস্তব প্রজেক্ট দাঁড় করাতে।
• AI-এর লেখা C++ কোড যাচাই করতে — আর দরকারে তার ভুল ধরতে।

পরীক্ষা ও সার্টিফিকেট

লগইন করলে ড্যাশবোর্ডে প্রতিটি মডিউলের টেস্ট আর একটি ফাইনাল পরীক্ষা পাবেন। সব পর্ব পড়া শেষ করে ফাইনালে ৬০% বা তার বেশি পেলে একটি ফ্রি কোর্স-সমাপ্তির সার্টিফিকেট পাবেন। প্রতিটি পর্বের “পড়েছি” বোতাম চাপা থাকলে আপনার অগ্রগতি সেখানে দেখা যাবে। পরীক্ষার আগে পর্ব ৫২–৫৪-এর প্রশ্নব্যাংক একবার ঘুরে আসুন।

অনুশীলন চালিয়ে যাওয়ার উপায়

• প্রতিদিন অল্প: দিনে একটি সমস্যা, পুরো সাত ধাপে — সপ্তাহে একদিন বড় সেশনের চেয়ে বেশি কাজে দেয়। LeetCode, HackerRank, Codeforces আর বাংলাদেশে জনপ্রিয় Toph-এর মতো প্ল্যাটফর্মে এ ধরনের অনেক সমস্যা পাবেন।
• একটি ভুলের খাতা: প্রতিটি ভুলের পর তিন লাইন — কোন ধারণা মিস করেছিলাম, কোন edge case ভুলেছিলাম, পরেরবার কোন সংকেত দেখে চিনব।
• ক্যাপস্টোন বড় করুন: নতুন একটি feature, আরও test, একটি পরিষ্কার README — GitHub-এ রাখলে portfolio নিজে থেকেই বড় হবে।
• অন্যকে শেখান: বন্ধুকে move semantics বোঝাতে গেলেই বুঝবেন নিজের কোথায় ফাঁক আছে।
• মাঝে মাঝে ফিরে আসুন: কোর্স হোম থেকে যে পর্ব দুর্বল লাগে সেটি আবার পড়ুন।

এরপর কোন পথে