DSA কেন শিখবেন — প্রতিটি প্রোগ্রামের পেছনের শক্তি

১ · স্বাগতম — এই কোর্স কার জন্য, কীভাবে সাজানো

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

ডেটা স্ট্রাকচার ও অ্যালগরিদম — সংক্ষেপে DSA — হলো প্রোগ্রামিংয়ের সেই অংশ, যা “কোড লিখতে পারা” থেকে “ভালো সমাধান বানাতে পারা”-য় নিয়ে যায়। ভাষা শেখা মানে বাক্য গঠন শেখা; DSA শেখা মানে কী বলবেন আর কীভাবে গুছিয়ে বলবেন, সেটি শেখা।

কোর্সটি কাদের জন্য

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

এই কোর্সে মোট ৭২টি পর্ব, ৯টি মডিউলে ভাগ করা। প্রতিটি পর্বে একই ছন্দ পাবেন, যাতে নতুন পর্বে ঢুকেই বুঝতে পারেন কোথায় কী আছে:

• আগে ধারণা: বাজারের সারি, ট্রেনের টিকিটের লাইন, লাইব্রেরির তাক বা ফোনবুকের মতো চেনা উদাহরণ দিয়ে শুরু।
• ধাপে ধাপে ডায়াগ্রাম (stepper): “পরে” বোতাম চেপে চেপে অ্যালগরিদমকে ছোট একটি ইনপুটে চলতে দেখবেন — প্রতিটি ধাপে অ্যারে, pointer বা টেবিলের অবস্থা বদলাবে। এগুলোই এই কোর্সের প্রাণ।
• C++ আর Python ট্যাব: মূল অ্যালগরিদমের কোড দুই ভাষায় পাশাপাশি; আপনার ভাষার ট্যাবটি বেছে নিন। “Run” চাপলে পাতাতেই চলবে।
• ভিজুয়ালাইজার: কোনো কোনো পর্বে ব্রাউজারে চলা ছোট টুল — স্লাইডার টেনে নিজে পরীক্ষা করবেন।
• বিশ্লেষণ ও প্রমাণ: সময় আর মেমরির হিসাব, আর যেখানে দরকার সেখানে কেন অ্যালগরিদমটি ঠিক — তার যুক্তি।
• “আরও গভীরে” আর “পরীক্ষা ও ইন্টারভিউতে” বক্স: প্রথমটি অভিজ্ঞদের জন্য বাড়তি তত্ত্ব; বাদ দিলেও কিছু হারাবেন না। দ্বিতীয়টিতে সাধারণ প্রশ্ন আর এক লাইনের উত্তর।
• শেষে: ভাবনার প্রশ্ন, হাতে-কলমে অনুশীলন আর নিজেকে যাচাইয়ের কুইজ।

২ · Data structure আর algorithm — কোনটা কী

একটি লাইব্রেরির কথা ভাবুন। হাজার হাজার বই। লাইব্রেরিয়ান বইগুলো কীভাবে রাখবেন — বিষয় অনুযায়ী তাকে, লেখকের নামের বর্ণানুক্রমে, নাকি যে যেখানে পারে রেখে দেবে? এই সাজিয়ে রাখার নিয়মটিই হলো data structure. আর একজন পাঠক যখন একটি বই চান, লাইব্রেরিয়ান যে পদ্ধতিতে খোঁজেন — প্রথম তাক থেকে একটি একটি করে দেখা, নাকি সরাসরি সঠিক তাকে গিয়ে মাঝখান থেকে খোঁজা — সেটি হলো algorithm.

দুটি আলাদা হলেও একটি আরেকটিকে ছাড়া অচল। বই এলোমেলো রাখলে সবচেয়ে বুদ্ধিমান খোঁজার পদ্ধতিও কাজ করবে না — একটি একটি করে সব দেখতেই হবে। আবার বই সুন্দর করে বর্ণানুক্রমে সাজানো থাকলেও খোঁজার সময় যদি প্রথম থেকে একটি একটি দেখেন, সাজানোর পরিশ্রম বৃথা। ভালো structure ভালো algorithm-এর সুযোগ তৈরি করে, আর ভালো algorithm সেই সুযোগ কাজে লাগায়।

আরেকটি কথা আগেই পরিষ্কার করে রাখি। Data structure-এর দুটি দিক আছে: কী কী কাজ করা যায় (যেমন “একটি নাম যোগ করো”, “নামটি আছে কি না বলো”) আর ভেতরে কীভাবে বানানো। প্রথমটিকে বলে abstract data type (ADT) — যেন রেস্তোরাঁর মেনু; দ্বিতীয়টি রান্নাঘরের আসল রেসিপি। একই মেনু (“নাম খোঁজো”) সাজানো array দিয়েও বানানো যায়, hash table দিয়েও। কোনটি বেছে নেবেন, তার ওপর নির্ভর করে কোন কাজ কত দ্রুত হবে — আর এই বাছাইয়ের দক্ষতাই এই কোর্সের কেন্দ্র।

৩ · একটি প্রশ্ন, তিনটি উত্তর — ১০ লাখ কন্ট্যাক্টে একটি নম্বর

ধরুন আপনি একটি মোবাইল অপারেটরের কাস্টমার কেয়ারের সফটওয়্যার বানাচ্ছেন। ডেটাবেসে ১০ লাখ গ্রাহকের নাম আর ফোন নম্বর। প্রতি সেকেন্ডে শত শত কল আসে, আর প্রতিটি কলে সফটওয়্যারকে একটি নম্বর খুঁজে বের করতে হয়। প্রশ্নটা সরল: “এই নম্বরটি তালিকায় আছে কি না, থাকলে কোথায়?” কিন্তু কীভাবে খুঁজবেন, তার ওপর নির্ভর করছে গ্রাহক এক মুহূর্ত অপেক্ষা করবেন, নাকি লাইনে বসে থাকবেন।

বোঝার সুবিধার জন্য প্রথমে ছোট করে দেখি — মাত্র ৮টি নাম, বর্ণানুক্রমে সাজানো। আমরা খুঁজব Nadia-কে। তিনটি পদ্ধতি একে একে দেখুন।

উত্তর ১ — একটি একটি করে দেখা (linear search)

সবচেয়ে সরল চিন্তা: প্রথম নাম থেকে শুরু করে একটি একটি মিলিয়ে দেখা, যতক্ষণ না পাওয়া যায়। এর নাম linear search. বাজারের লম্বা সারিতে একজন পরিচিত মানুষকে খুঁজতে যেমন সামনে থেকে প্রত্যেকের মুখ দেখে দেখে এগোন।

1for (int i = 0; i < n; i++)2    if (name[i] == target)3        return i;          // found4return -1;                 // not found

উত্তর ২ — মাঝখান থেকে অর্ধেক বাদ (binary search)

অভিধানে “নদী” শব্দটি খুঁজতে কেউ প্রথম পাতা থেকে শুরু করেন না। মাঝামাঝি একটি পাতা খোলেন; সেখানে “ত” দিয়ে শব্দ থাকলে বোঝেন “ন” আরও পরে — সামনের অর্ধেক আর দেখার দরকারই নেই। তালিকা সাজানো থাকলে এই কৌশলটিই binary search: প্রতিবার মাঝের নামটির সাথে তুলনা করে বাকি অংশের অর্ধেক বাদ দেওয়া।

1int lo = 0, hi = n - 1;2while (lo <= hi) {3    int mid = lo + (hi - lo) / 2;4    if (name[mid] == target) return mid;5    if (name[mid] < target) lo = mid + 1;6    else hi = mid - 1;7}8return -1;

উত্তর ৩ — সরাসরি ঠিকানায় যাওয়া (hash table)

পুরোনো দিনের মোটা ফোনবুকের পাশে A, B, C… লেখা ট্যাব থাকত। “Nadia” খুঁজতে সরাসরি N-এর ট্যাবে চলে যেতেন — বাকি বইয়ের দিকে তাকানোরই দরকার পড়ত না। Hash table এই চিন্তারই কম্পিউটার রূপ। একটি hash function প্রতিটি নাম থেকে একটি সংখ্যা বানায় — সেই সংখ্যাটিই নামটির “তাক” বা bucket. খোঁজার সময় একই হিসাব করে সরাসরি সেই তাকে চলে যান।

নিচের উদাহরণে খেলনা-ধরনের একটি hash function নিচ্ছি: নামের প্রথম অক্ষরের ক্রম (A = 1, B = 2, … Z = 26) কে 5 দিয়ে ভাগ করে ভাগশেষ। অর্থাৎ ৫টি তাক, নম্বর 0 থেকে 4.

তিন উত্তর পাশাপাশি

তাহলে কি hash table সবসময় সেরা? না। Binary search-এর সাজানো তালিকা দিয়ে “Nadia-র পরের নাম কে?” বা “M থেকে R পর্যন্ত সব নাম দাও” — এমন প্রশ্নের উত্তর সহজেই দেওয়া যায়; hash table-এ নামগুলো এলোমেলো তাকে ছড়ানো, তাই এসব প্রশ্নে সে অসহায়। Linear search-এরও জায়গা আছে: তালিকা ছোট হলে বা মাত্র একবার খুঁজতে হলে সাজানো বা table বানানোর খরচই বেশি পড়ে। সেরা data structure বলে কিছু নেই — আছে কাজ অনুযায়ী সঠিক data structure. এই সিদ্ধান্ত নিতে পারাই DSA শেখার আসল লক্ষ্য।

৪ · নিজে চালিয়ে দেখুন — ১০ লাখ নম্বরে ধাপ গোনা

এবার আসল আকারে পরীক্ষা। নিচের প্রোগ্রাম ১০ লাখ ফোন নম্বরের একটি সাজানো তালিকা বানায় (01711000000 থেকে শুরু করে ৭ করে বেড়ে চলা নম্বর)। তারপর একই নম্বরগুলো দিয়ে একটি hash table বানায়। এরপর চারটি নম্বর খোঁজে — তালিকার প্রথম, মাঝের, শেষের, আর একটি যা তালিকায় নেই — এবং তিন পদ্ধতিতে কতগুলো তুলনা লাগল, গুনে দেখায়। আপনার ভাষার ট্যাব বেছে নিয়ে “Run” চাপুন।

Hash table-টি এখানে একটু ভিন্ন কৌশলে বানানো: প্রতিটি তাকে একটিই নম্বর থাকে, আর তাক ভরা থাকলে পরের খালি তাকে বসানো হয় — একে বলে linear probing. খোঁজার সময়ও একই পথে এগোনো হয়, যতক্ষণ না নম্বরটি বা একটি খালি তাক পাওয়া যায়।

#include <print>
#include <vector>

int main() {
    const int n = 1'000'000;
    std::vector<long long> phone(n);                  // sorted contact list
    for (int i = 0; i < n; ++i) phone[i] = 1711000000LL + 7LL * i;

    const int M = 1 << 21;                            // hash table, under half full
    std::vector<long long> table(M, -1);
    for (long long p : phone) {
        int h = p % M;
        while (table[h] != -1) h = (h + 1) % M;       // linear probing
        table[h] = p;
    }
    std::println("contacts: {}", n);
    std::println("{:<12} {:>8} {:>7} {:>5}", "number", "linear", "binary", "hash");
    for (long long t : {phone[0], phone[n / 2], phone[n - 1], 1711000003LL}) {
        int lin = 0;
        for (long long p : phone) { ++lin; if (p == t) break; }
        int bin = 0, lo = 0, hi = n - 1;
        while (lo <= hi) {
            int mid = lo + (hi - lo) / 2;
            ++bin;
            if (phone[mid] == t) break;
            if (phone[mid] < t) lo = mid + 1; else hi = mid - 1;
        }
        int hs = 0;
        for (int h = t % M; ; h = (h + 1) % M) {
            ++hs;
            if (table[h] == t || table[h] == -1) break;
        }
        std::println("0{:<11} {:>8} {:>7} {:>5}", t, lin, bin, hs);
    }
}

contacts: 1000000
number         linear  binary  hash
01711000000         1      19     1
01714500000    500001      19     1
01717999993   1000000      20     1
01711000003   1000000      20     1

n = 1_000_000
phone = [1711000000 + 7 * i for i in range(n)]        # sorted contact list

M = 1 << 21                                           # hash table, under half full
table = [-1] * M
for p in phone:
    h = p % M
    while table[h] != -1:
        h = (h + 1) % M                               # linear probing
    table[h] = p

print("contacts:", n)
print(f"{'number':<12} {'linear':>8} {'binary':>7} {'hash':>5}")
for t in (phone[0], phone[n // 2], phone[n - 1], 1711000003):
    lin = 0
    for p in phone:                                   # linear scan
        lin += 1
        if p == t: break
    bin_, lo, hi = 0, 0, n - 1
    while lo <= hi:
        mid = lo + (hi - lo) // 2
        bin_ += 1
        if phone[mid] == t:
            break
        if phone[mid] < t:
            lo = mid + 1
        else:
            hi = mid - 1
    hs, h = 0, t % M
    while True:
        hs += 1
        if table[h] == t or table[h] == -1:
            break
        h = (h + 1) % M
    print(f"0{t:<11} {lin:>8} {bin_:>7} {hs:>5}")

contacts: 1000000
number         linear  binary  hash
01711000000         1      19     1
01714500000    500001      19     1
01717999993   1000000      20     1
01711000003   1000000      20     1

দৌড় প্রতিযোগিতা — নিজে আকার বদলে দেখুন

নিচের ছোট টুলে স্লাইডার টেনে তালিকার আকার ১০ থেকে ১ কোটি পর্যন্ত বদলান, তারপর “নতুন দৌড়” চাপুন। একটি এলোমেলো নম্বর বেছে দুই পদ্ধতিকে একই গতিতে (প্রতি মুহূর্তে সমান সংখ্যক তুলনা) দৌড়াতে দেওয়া হবে। প্রথমবার “Run” চাপলে সবচেয়ে খারাপ ক্ষেত্রটি চলবে — ১০ লাখের শেষ নম্বর।

// Linear vs binary search on the sorted list 0, 1, ..., n-1
const SIZES = [10, 100, 1000, 10000, 100000, 1000000, 10000000];
const $ = (id) => document.getElementById(id);
const fmt = (x) => x.toLocaleString("en-US");
let timer = null;

function binarySteps(n, t) {
  let lo = 0, hi = n - 1, steps = 0;
  while (lo <= hi) {
    const mid = lo + Math.floor((hi - lo) / 2); steps++;
    if (mid === t) break;
    if (mid < t) lo = mid + 1; else hi = mid - 1;
  }
  return steps;
}
function race(n, t) {
  const lin = t + 1, bin = binarySteps(n, t);      // linear checks 0, 1, ..., t
  console.log(`n = ${n}, target = ${t}: linear ${lin}, binary ${bin} comparisons`);
  clearInterval(timer);
  let done = 0;
  const speed = Math.max(1, Math.ceil(lin / 100));   // about 100 frames
  timer = setInterval(() => {
    done = Math.min(lin, done + speed);
    $("lc").textContent = fmt(done);
    $("bc").textContent = Math.min(done, bin);
    $("lb").style.width = (done / n * 100) + "%";
    $("bb").style.width = Math.max(Math.min(done, bin) / n * 100, 0.5) + "%";
    if (done === lin) clearInterval(timer);
  }, 20);
}
$("sz").oninput = () => { $("nv").textContent = fmt(SIZES[$("sz").value]); };
$("go").onclick = () => { const n = SIZES[$("sz").value]; race(n, Math.floor(Math.random() * n)); };
race(1000000, 999999);                               // first run: worst case for linear

৫ · বাস্তব জগতে DSA — আপনি প্রতিদিন যা ব্যবহার করেন

DSA শুধু পরীক্ষা বা কনটেস্টের বিষয় নয়। আপনার ফোনের প্রায় প্রতিটি অ্যাপের ভেতরে এগুলো চুপচাপ কাজ করছে। কোম্পানিগুলোর ভেতরের নির্দিষ্ট প্রযুক্তি সবসময় প্রকাশ্য নয়, তবে এই ধরনের কাজে সাধারণত কোন ধারণাগুলো লাগে, তা জানা আছে:

খেয়াল করুন, প্রতিটি উদাহরণে প্রশ্নটা একই রকম: ডেটা অনেক, সময় কম। ১০০টি রেকর্ডে যেকোনো পদ্ধতিই চলে। ১০ কোটি রেকর্ডে শুধু সঠিক data structure আর algorithm-ই চলে। এজন্যই বড় সফটওয়্যার কোম্পানিগুলোর ইন্টারভিউতে DSA-র প্রশ্ন এত বেশি — তাঁরা দেখতে চান, ডেটা বাড়লে আপনার সমাধান টিকবে কি না।

৬ · কীভাবে মাপব — Big-O-র প্রথম ঝলক

“আমার প্রোগ্রাম ০.৫ সেকেন্ডে চলে” — এই কথায় তেমন তথ্য নেই। কোন কম্পিউটারে? কত বড় ইনপুটে? নতুন ল্যাপটপে যা ০.৫ সেকেন্ড, পুরোনোটিতে হয়তো ২ সেকেন্ড। তাই অ্যালগরিদম মাপা হয় অন্যভাবে: ইনপুটের আকার n বাড়লে কাজের পরিমাণ কোন হারে বাড়ে? এই হারকে প্রকাশ করার ভাষার নাম Big-O notation.

• Time complexity — n-এর তুলনায় ধাপের সংখ্যা কীভাবে বাড়ে। Linear search: O(n), কারণ সবচেয়ে খারাপে প্রতিটি ঘর একবার দেখা হয়। Binary search: O(log n), কারণ প্রতি তুলনায় বাকি অংশ অর্ধেক হয়, আর n কে অর্ধেক করতে করতে ১-এ নামাতে log₂ n বার লাগে।
• Space complexity — বাড়তি মেমরি কতটা লাগে। Linear ও binary search দুটিই O(1) বাড়তি জায়গা নেয় (শুধু কয়েকটি ভ্যারিয়েবল)। Hash table বানাতে লাগে O(n) বাড়তি জায়গা।

একটি মোটা দাগের আন্দাজ মনে রাখুন: সাধারণ কম্পিউটার সেকেন্ডে মোটামুটি 10⁸ (১০ কোটি) সরল কাজ করতে পারে — এটি নিখুঁত মাপ নয়, শুধু হিসাবের সুবিধার জন্য। সেই হিসাবে n = 10⁶-এ O(n log n) অ্যালগরিদম এক সেকেন্ডের অনেক কম সময় নেয়, কিন্তু O(n²) নেয় প্রায় 10⁴ সেকেন্ড — পৌনে তিন ঘণ্টা! কম্পিউটার দশ গুণ দ্রুত হলেও O(n²) সেখানে টিকবে না; কিন্তু ভালো অ্যালগরিদম পুরোনো কম্পিউটারেও টিকে যায়।

৭ · কোন ভাষায় — C++ আর Python কেন

অ্যালগরিদম কোনো ভাষার সম্পত্তি নয় — binary search C-তে যা, Python-এও তাই। তবু কোড লিখতে একটি ভাষা তো লাগবেই। এই কোর্সে মূল ভাষা দুটি:

প্রতিটি মূল অ্যালগরিদম দুই ভাষাতেই পাবেন, একই ইনপুটে একই আউটপুট দিয়ে — যেমন উপরের ফোন নম্বরের প্রোগ্রাম। যেটিতে স্বচ্ছন্দ, সেটি পড়ুন; অন্যটিতে চোখ বুলালে দুই ভাষার পার্থক্যও শিখে ফেলবেন। C++ নতুন হলে আমাদের C++ প্রোগ্রামিং কোর্স আর বিশেষ করে STL অ্যালগরিদমের পর্বটি কাজে লাগবে; Python-এর জন্য আছে Python প্রোগ্রামিং কোর্স.

৮ · রোডম্যাপ — ৯টি মডিউল, ৭২টি পর্ব

পুরো কোর্সটি একটি সিঁড়ির মতো: প্রতিটি মডিউল আগেরটির ওপর দাঁড়িয়ে নতুন কিছু “খুলে” দেয়। “পরে” চেপে মডিউলগুলো একে একে দেখুন:

৯ · কীভাবে অনুশীলন করবেন — হাত, মাথা আর online judge

DSA পড়ে শেখার বিষয় নয়, করে শেখার বিষয় — সাঁতারের মতো। বই পড়ে সাঁতার শেখা যায় না। নিচের চারটি অভ্যাস পুরো কোর্সে আপনার সঙ্গী হবে:

1. হাতে ট্রেস করা — dry run বা ড্রাই রান। খাতা-কলম নিয়ে ছোট একটি ইনপুটে অ্যালগরিদম ধাপে ধাপে চালান — প্রতিটি ভ্যারিয়েবলের মান একটি টেবিলে লিখে। উপরের stepper-গুলো ঠিক এটাই করে; এবার আপনি নিজে করবেন। বিশ্ববিদ্যালয় ও চাকরির লিখিত পরীক্ষায় এই দক্ষতা সরাসরি নম্বর আনে।
2. Brute force দিয়ে মিলিয়ে দেখা। দ্রুত সমাধান লেখার আগে বা পরে একটি ধীর কিন্তু নিশ্চিতভাবে ঠিক সমাধান লিখুন — যেমন binary search-এর পাশে linear search. ছোট ইনপুটে দুটির উত্তর মিলিয়ে দেখুন। Brute force হলো আপনার “উত্তরপত্র”।
3. Stress testing. এলোমেলো ছোট ইনপুট বানিয়ে হাজারবার দুটি সমাধান চালানো, যতক্ষণ না কোনো অমিল পাওয়া যায়। অমিল পেলে সেই ছোট ইনপুটটিই আপনার বাগের ঠিকানা। Stress testing কনটেস্ট প্রোগ্রামারদের সবচেয়ে কাজের অস্ত্রগুলোর একটি।
4. Online judge-এ নিয়মিত সমস্যা। Online judge হলো এমন ওয়েবসাইট, যেখানে সমস্যা পড়ে কোড জমা দিলে সার্ভার গোপন অনেকগুলো ইনপুটে চালিয়ে বলে দেয় — Accepted, Wrong Answer, নাকি Time Limit Exceeded.

বাংলাদেশের কনটেস্ট সংস্কৃতি

Competitive programming-এ বাংলাদেশের একটি সমৃদ্ধ ঐতিহ্য আছে। বহু বছর ধরে ঢাকায় আন্তর্জাতিক কলেজিয়েট প্রোগ্রামিং কনটেস্টের এশীয় আঞ্চলিক পর্ব — ICPC Asia Dhaka Regional — অনুষ্ঠিত হয়, যেখানে দেশ-বিদেশের বিশ্ববিদ্যালয়ের দল অংশ নেয়, আর বাংলাদেশের দলগুলো নিয়মিত ICPC World Finals-এ খেলেছে। দেশের ভেতরে আছে জাতীয় কলেজিয়েট প্রোগ্রামিং কনটেস্ট (NCPC) আর বিভিন্ন বিশ্ববিদ্যালয়ের আয়োজনে অসংখ্য IUPC (Inter University Programming Contest). স্কুল-কলেজের শিক্ষার্থীদের জন্য আছে জাতীয় হাই স্কুল প্রোগ্রামিং কনটেস্ট আর ইনফরমেটিক্স অলিম্পিয়াড। এসব কনটেস্টের সমস্যার হৃদয়ই হলো DSA.

১০ · AI-এর যুগে DSA — সহকারী আছে, বিচারক আপনি

আজ যেকোনো AI-কে বললেই binary search বা Dijkstra-র কোড লিখে দেয়। তাহলে DSA শেখার দরকার কী? উত্তর: AI খুব দ্রুত লিখতে পারে, কিন্তু সে যা লেখে তা ঠিক কি না, যথেষ্ট দ্রুত কি না, আর আপনার সমস্যার জন্যই উপযুক্ত কি না — এই বিচার করতে হয় আপনাকে। DSA না জানলে আপনি সেই বিচার করতে পারবেন না; তখন AI-এর ভুলও আপনার ভুল হয়ে যাবে।

DSA-তে AI সাধারণত যেসব ভুল করে

AI-এর দেওয়া অ্যালগরিদম হাতে পেলে — যাচাইয়ের চেকলিস্ট

• ছোট একটি ইনপুটে খাতায় হাতে ট্রেস করেছি, প্রতিটি ধাপের মান মিলিয়েছি
• একটি সরল brute force লিখে শত শত এলোমেলো ছোট ইনপুটে দুটির উত্তর মিলিয়েছি
• খালি ইনপুট, একটি মাত্র উপাদান, সব সমান উপাদান আর সর্বোচ্চ সীমার ইনপুট দিয়ে চালিয়েছি
• AI যে complexity বলেছে, লুপ গুনে নিজে মিলিয়েছি — আর সর্বোচ্চ n-এ সময়সীমার মধ্যে চলবে কি না হিসাব করেছি
• Greedy বা চতুর কৌশল হলে জিজ্ঞেস করেছি “কেন এটি সবসময় ঠিক?” — প্রমাণ বা অন্তত একটি পাল্টা-উদাহরণ খুঁজেছি