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

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

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

Python এখন ইন্টারভিউর সবচেয়ে জনপ্রিয় ভাষাগুলোর একটি। কারণ সহজ: কম লাইনে ভাবনাটা কোডে আনা যায়, আর ইন্টারভিউয়ার আপনার যুক্তিতে মন দিতে পারেন। কিন্তু এর একটি উল্টো দিকও আছে। Python-এ sorted(), Counter বা heapq এক লাইনে অনেক কাজ করে দেয় — তাই ইন্টারভিউয়ার প্রায়ই জিজ্ঞেস করেন, “এই এক লাইনের খরচ কত?” built-in ব্যবহার করা ভালো, কিন্তু তার ভেতরের জটিলতা জানা আরও জরুরি।

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

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

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

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

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

• “একটি LRU cache লিখুন” — get ও put দুটোই O(1); OrderedDict চেনেন কি না, আর functools.lru_cache ভেতরে কী করে (সমস্যা ১৪; পর্ব ২৭, ৩৮)।
• “একটি decorator লিখুন” — যেমন @retry বা @timer; closure আর functools.wraps বোঝেন কি না (সমস্যা ১৫; পর্ব ২০, ৩৫)।
• “একটি context manager লিখুন” — সময় মাপা বা transaction-এর জন্য; __enter__/__exit__ আর contextlib (সমস্যা ১৬; পর্ব ৩৬)।
• “একটি iterator class লিখুন” আর “একটি dataclass মডেল বানান” — __iter__/__next__, @dataclass(frozen=True), যাচাই (সমস্যা ১৭; পর্ব ৩২, ৩৪)।
• “GIL কী, আর কেন গুরুত্বপূর্ণ?” — thread, process আর free-threaded Python-এর পার্থক্য (অংশ ৭, প্র ০৬; পর্ব ৪১)।

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

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

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

পুরো সময় জুড়ে একটি নিয়ম: জোরে ভাবুন (think aloud). চুপ করে দুই মিনিট ভাবার চেয়ে অর্ধেক-গোছানো ভাবনা বলাও ভালো — ইন্টারভিউয়ার পথ দেখে সাহায্য করতে পারেন। এবার পদ্ধতিটি একটি বিখ্যাত সমস্যায় প্রয়োগ করি — সমস্যা ১ · Two sum (সহজ): “একটি list[int] আর একটি target দেওয়া আছে। এমন দুটি ভিন্ন index বের করুন, যাদের মানের যোগফল target.” নিচের ডায়াগ্রামে “পরে” চাপুন:

- উত্তর সবসময় থাকবে, নাকি নাও থাকতে পারে?
- একই index দুবার নেওয়া যাবে? (না)
- list কি সাজানো? (না)
- 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 ->  None    5+5 চলবে না

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

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

for j, x in enumerate(nums):
    if target - x in seen: return seen[target - x], j
    seen[x] = j       # আগে খুঁজি, পরে রাখি
return None           # "নেই" স্পষ্টভাবে

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

dict: সময় O(n) গড়ে, মেমরি O(n)
- list সাজানো হলে? -> দুই পয়েন্টার, O(1) মেমরি
- সব জোড়া চাই? 3-sum? -> সাজিয়ে + দুই পয়েন্টার, O(n²)
- ডেটা stream-এ এলে? -> একই dict, এক পাসেই

def two_sum(nums: list[int], target: int) -> tuple[int, int] | None:
    seen: dict[int, int] = {}              # value -> index
    for j, x in enumerate(nums):
        need = target - x
        if need in seen:                   # look first ...
            return seen[need], j
        seen[x] = j                        # ... then remember
    return None


tests = [([2, 7, 11, 15], 9), ([3, 3], 6), ([-3, 4, 3, 90], 0), ([5], 10), ([], 1)]
for nums, target in tests:
    print(f"{nums}, {target} -> {two_sum(nums, target)}")

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

প্রায় প্রতিটি ইন্টারভিউর প্রথম প্রশ্ন এই গোত্রের। দেখতে সহজ, কিন্তু এখানেই বোঝা যায় আপনি slicing, str-এর method, dict, Counter আর defaultdict স্বাভাবিকভাবে ব্যবহার করেন কি না। রিভিশনের জন্য: পর্ব ০৯ · string ও বাংলা Unicode, পর্ব ১৪ · list, পর্ব ১৬ · dictionary, পর্ব ১৭ · set, পর্ব ১৮ · comprehension, পর্ব ২৭ · collections.

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

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

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

পদ্ধতি ও জটিলতা: argument ছাড়া split() যেকোনো পরিমাণ whitespace দিয়ে ভাগ করে আর খালি টুকরো বাদ দেয় — এটাই সমস্যার অর্ধেক। তারপর reversed আর " ".join. সময় O(n), মেমরি O(n).

def reverse_words(s: str) -> str:
    return " ".join(reversed(s.split()))     # split() drops every extra space

# reverse_words("  hello   world  ")  ->  "world hello"
# reverse_words("   ")                ->  ""

Edge case ও ফলো-আপ: split(" ") (argument সহ) লিখলে ভুল হয় — পরপর দুটি space-এর মাঝে খালি string তৈরি হয়। এটা ইন্টারভিউয়ারের প্রিয় ফাঁদ। ফলো-আপে প্রায়ই বলা হয়: “built-in ছাড়া লিখুন।” তখন একটি index দিয়ে string পার হয়ে শব্দ জমান। আর “in-place করুন” বললে মনে করিয়ে দিন — Python-এর str immutable, তাই আগে list(s) বানাতে হবে; তারপর পুরো list উল্টে প্রতিটি শব্দ আবার উল্টানোর two pointers কৌশল।

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

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

জিজ্ঞেস করে নিন: বড়-ছোট হাতের পার্থক্য ধরব? space বা যতিচিহ্ন গুনব? দলগুলোর ক্রম কি গুরুত্বপূর্ণ?

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

from collections import Counter, defaultdict


def is_anagram(a: str, b: str) -> bool:
    return len(a) == len(b) and Counter(a) == Counter(b)


def group_anagrams(words: list[str]) -> list[list[str]]:
    groups: defaultdict[str, list[str]] = defaultdict(list)
    for w in words:
        groups["".join(sorted(w))].append(w)   # "eat", "tea" -> key "aet"
    return list(groups.values())


print(is_anagram("listen", "silent"), is_anagram("rat", "car"), is_anagram("", ""))
print(is_anagram("Listen", "Silent"), is_anagram("Listen".casefold(), "Silent".casefold()))
for group in group_anagrams(["eat", "tea", "tan", "ate", "nat", "bat"]):
    print(group)

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

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

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

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

1def longest_unique(s):2    last = {}3    best = left = 04    for right, ch in enumerate(s):5        if last.get(ch, -1) >= left:6            left = last[ch] + 17        last[ch] = right8        best = max(best, right - left + 1)9    return best

def longest_unique(s: str) -> int:
    last: dict[str, int] = {}          # char -> last index seen
    best = left = 0                    # window is s[left:right + 1]
    for right, ch in enumerate(s):
        if last.get(ch, -1) >= left:   # repeat inside the window?
            left = last[ch] + 1        # jump past the previous copy
        last[ch] = right
        best = max(best, right - left + 1)
    return best


for s in ["abcabcbb", "bbbbb", "pwwkew", "", "abba", "আমার আমি"]:
    print(f"{s!r} -> {longest_unique(s)}")

সমস্যা ৫ · Palindrome যাচাই — যতিচিহ্ন বাদ, আর বাংলার কথা (সহজ)

প্রশ্ন: বড়-ছোট হাতের পার্থক্য, space আর যতিচিহ্ন বাদ দিলে একটি বাক্য সামনে-পেছনে একই কি না বলুন। “A man, a plan, a canal: Panama” → True.

জিজ্ঞেস করে নিন: “অক্ষর” মানে শুধু ইংরেজি অক্ষর ও সংখ্যা? Unicode ইনপুট (বাংলা) আসবে? বাড়তি মেমরি O(1) রাখতে হবে?

পদ্ধতি ও জটিলতা: সহজ পথ: পরিষ্কার করা অক্ষরের list বানিয়ে উল্টোটার সাথে তুলনা — O(n) সময়, O(n) মেমরি। ইন্টারভিউয়ার সাধারণত দেখতে চান two pointers: দুই প্রান্ত থেকে ভেতরে আসুন, অপ্রাসঙ্গিক অক্ষর লাফিয়ে যান — O(n) সময়, O(1) বাড়তি মেমরি।

import unicodedata


def is_palindrome(s: str) -> bool:
    """Two pointers; ignore case, spaces and punctuation."""
    i, j = 0, len(s) - 1
    while i < j:
        if not s[i].isalnum():
            i += 1
        elif not s[j].isalnum():
            j -= 1
        elif s[i].casefold() != s[j].casefold():
            return False
        else:
            i, j = i + 1, j - 1
    return True


def is_palindrome_unicode(s: str) -> bool:
    s = unicodedata.normalize("NFC", s)
    keep = [c.casefold() for c in s if unicodedata.category(c)[0] in "LNM"]
    return keep == keep[::-1]          # L = letter, N = number, M = mark


print(is_palindrome("A man, a plan, a canal: Panama"), is_palindrome("race a car"), is_palindrome(""))
print(is_palindrome("কাকি"), is_palindrome_unicode("কাকি"))
print("য়" == "য়",
      unicodedata.normalize("NFC", "য়") == unicodedata.normalize("NFC", "য়"))

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

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

পদ্ধতি ও জটিলতা: দুবার পার হোন — প্রথমবার Counter দিয়ে গুনুন, দ্বিতীয়বার মূল string-এর ক্রমে প্রথম যার গণনা ১, সেটি ফেরত দিন। সময় O(n), মেমরি O(ভিন্ন অক্ষর)। next()-এর দ্বিতীয় argument “না পেলে কী দেব” বলে দেয় — আলাদা লুপ আর flag লাগে না।

from collections import Counter


def first_unique(s: str) -> str | None:
    counts = Counter(s)
    return next((ch for ch in s if counts[ch] == 1), None)

# first_unique("swiss") -> "w"     first_unique("aabb") -> None

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

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

এই গোত্রে দুটি জিনিস একসাথে যাচাই হয়: ঠিক data structure চেনা, আর Python-এর কোন built-in কোন কাজে দ্রুত তা জানা। list-এর শেষে append/pop সস্তা, কিন্তু শুরুতে নয় — এই একটি তথ্যই অনেক প্রশ্নের চাবি। রিভিশনের জন্য: পর্ব ১৪ · list, পর্ব ১৯ · mutability ও alias, পর্ব ২৭ · collections, পর্ব ২৯ · class, পর্ব ৩২ · dataclass.

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

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

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

পদ্ধতি ও জটিলতা: শেষে যে খুলেছে, তাকেই আগে বন্ধ হতে হবে — এটাই LIFO, অর্থাৎ stack. Python-এ আলাদা stack class লাগে না — সাধারণ list-এর append আর pop দুটোই শেষ প্রান্তে, গড়ে O(1). সময় O(n), মেমরি O(n).

PAIRS = {")": "(", "]": "[", "}": "{"}


def is_balanced(s: str) -> bool:
    stack: list[str] = []
    for ch in s:
        if ch in "([{":
            stack.append(ch)
        elif ch in PAIRS:
            if not stack or stack.pop() != PAIRS[ch]:
                return False
    return not stack                  # a leftover opener = unbalanced

# "()[]{}" True · "([)]" False · "{[()]}" True · "((" False · ")(" False · "" True

Edge case ও ফলো-আপ: দুটি ফাঁদ এখানে ধরা পড়ে: ")(" — খালি list-এ pop() করলে IndexError, তাই আগে not stack যাচাই (or-এর short-circuit দ্বিতীয় অংশ চালায়ই না); আর "((" — লুপ শেষে stack খালি না হলে উত্তর False. ফলো-আপ: শুধু এক ধরনের বন্ধনী হলে stack-ও লাগে না — একটি গণনা যথেষ্ট (O(1) মেমরি)। প্রথম ভুলের অবস্থান ফেরত দিন। সবচেয়ে কম কয়টি বন্ধনী মুছলে balanced হবে?

সমস্যা ৮ · Min-stack, আর deque দিয়ে queue (মাঝারি)

প্রশ্ন: (ক) একটি stack class ডিজাইন করুন, যেখানে push, pop, top আর get_min — চারটিই O(1). (খ) মেট্রো রেলের টিকিট কাউন্টারের লাইনের মতো একটি queue বানান: যে আগে আসে, সে আগে যায়; দুই কাজই O(1).

জিজ্ঞেস করে নিন: খালি stack বা queue থেকে নিতে চাইলে কী হবে — exception, নাকি None? মানগুলো কি শুধু সংখ্যা?

পদ্ধতি ও জটিলতা: (ক) প্রতিটি উপাদানের পাশে “এখন পর্যন্ত নিচের সবার সর্বনিম্ন” জমা রাখুন — (value, min_so_far) tuple. pop করলে সেই তথ্যও চলে যায়, আগের সর্বনিম্ন নিজে থেকে ফিরে আসে। সব কাজ O(1), মেমরি ২n. (খ) list-এর pop(0) O(n) — প্রথমটি সরালে বাকি সবাইকে এক ঘর বাঁয়ে সরাতে হয়। collections.deque দুই প্রান্তেই O(1).

from collections import deque


class MinStack:
    def __init__(self) -> None:
        self._items: list[tuple[int, int]] = []     # (value, min of it and below)

    def push(self, x: int) -> None:
        low = min(x, self._items[-1][1]) if self._items else x
        self._items.append((x, low))

    def pop(self) -> int:
        if not self._items:
            raise IndexError("pop from empty MinStack")
        return self._items.pop()[0]

    def top(self) -> int:
        return self._items[-1][0]                   # IndexError when empty

    def get_min(self) -> int:
        return self._items[-1][1]


class TicketQueue:
    def __init__(self) -> None:
        self._q: deque[str] = deque()

    def join(self, name: str) -> None:
        self._q.append(name)                        # O(1) at the back

    def serve(self) -> str:
        if not self._q:
            raise IndexError("queue is empty")
        return self._q.popleft()                    # O(1); list.pop(0) is O(n)

    def __len__(self) -> int:
        return len(self._q)

Edge case ও ফলো-আপ: 5, 3, 7, 3, 1 push করলে প্রতিবারের get_min: 5, 3, 3, 3, 1; ডুপ্লিকেট সর্বনিম্ন (দুটি 3) কোনো বিশেষ ব্যবস্থা ছাড়াই ঠিক চলে। __len__ লিখলে len(q) আর if q: দুটোই স্বাভাবিকভাবে কাজ করে — এটাই Python-এর data model (পর্ব ৩০)। এক ধাপ এগিয়ে নিজেকে জিজ্ঞেস করুন: self._items-এ underscore কেন? — বাইরের কোডকে বলা “এটা ছুঁয়ো না”, যাতে invariant ভাঙা না যায় (পর্ব ২৯)। ফলো-আপ: “দুটি stack দিয়ে queue বানান” — একটিতে ঢোকান, অন্যটি খালি হলে প্রথমটির সব উল্টে ঢেলে দিন; প্রতিটি উপাদান মোট দুবার সরে, তাই গড়ে (amortized) O(1). thread-এর মধ্যে কাজ ভাগ করতে queue.Queue (পর্ব ৪১)।

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

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

জিজ্ঞেস করে নিন: Node class কি দেওয়া আছে, নাকি আমি বানাব? খালি লিস্ট (None) আসতে পারে? (আসতে পারে।)

পদ্ধতি ও জটিলতা: Python-এ built-in linked list নেই, তাই ছোট একটি dataclass দিয়ে Node বানাই — __init__ আর __repr__ নিজে লিখতে হয় না (পর্ব ৩২)। তিনটি হাত — উল্টানো অংশ (prev), বর্তমান node (head), বাকি অংশ (rest). সময় O(n), মেমরি O(1).

from dataclasses import dataclass


@dataclass
class Node:
    val: int
    next: "Node | None" = None


def reverse(head: Node | None) -> Node | None:
    prev = None
    while head is not None:
        rest = head.next       # 1. hold on to the rest
        head.next = prev       # 2. turn the arrow around
        prev = head            # 3. grow the reversed part
        head = rest            # 4. step forward
    return prev


def from_list(values: list[int]) -> Node | None:
    head = None
    for v in reversed(values):
        head = Node(v, head)
    return head


def to_list(head: Node | None) -> list[int]:
    out = []
    while head:
        out.append(head.val)
        head = head.next
    return out


for values in ([1, 2, 3, 4, 5], [], [9]):
    print(values, "->", to_list(reverse(from_list(values))))

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

এই অংশের সমস্যাগুলোতে কৌশল চেনাই আসল: “সাজানো” শুনলে binary search, “স্তরে স্তরে” শুনলে queue, “সবচেয়ে বড় k টি” শুনলে heap, “কত উপায়ে / সর্বনিম্ন কত” শুনলে DP. রিভিশনের জন্য: পর্ব ১৩ · ফাংশন, পর্ব ৩৪ · generator ও yield from, পর্ব ৩৫ · decorator ও cache, পর্ব ৩৮ · functools ও itertools, পর্ব ৪৫ · অ্যালগরিদম ও কনটেস্ট.

সমস্যা ১০ · BST-তে insert, inorder আর level-order (সহজ → মাঝারি)

প্রশ্ন: একটি binary search tree-তে key যোগ করুন। তারপর (ক) সব key সাজানো ক্রমে, আর (খ) স্তর ধরে বের করুন: [[50], [30, 70], [20, 40, 60, 80], [35]].

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

পদ্ধতি ও জটিলতা: insert: ছোট হলে বাঁয়ে, নইলে ডানে, খালি জায়গা পেলে সেখানে নতুন node. Inorder traversal (বাঁ → root → ডান) BST-তে সবসময় সাজানো ক্রম দেয়; yield from দিয়ে এটি একটি generator হয়। Level-order মানে BFS: আগে দেখা node-এর সন্তানদের আগে দেখা — FIFO, তাই deque. স্তর আলাদা করার কৌশল: প্রতিটি স্তর শুরুর সময় queue-তে কয়টি node আছে গুনে ঠিক ততগুলোই বের করুন। insert O(h), দুই traversal O(n); h হলো উচ্চতা।

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass


@dataclass
class Tree:
    key: int
    left: "Tree | None" = None
    right: "Tree | None" = None


def insert(t: Tree | None, key: int) -> Tree:
    if t is None:
        return Tree(key)
    if key < t.key:
        t.left = insert(t.left, key)
    else:
        t.right = insert(t.right, key)
    return t


def inorder(t: Tree | None) -> Iterator[int]:      # left, root, right = sorted
    if t:
        yield from inorder(t.left)
        yield t.key
        yield from inorder(t.right)


def level_order(root: Tree | None) -> list[list[int]]:
    levels, q = [], deque([root] if root else [])
    while q:
        level = []
        for _ in range(len(q)):                    # exactly one level per pass
            t = q.popleft()
            level.append(t.key)
            q.extend(c for c in (t.left, t.right) if c)
        levels.append(level)
    return levels


root = None
for k in [50, 30, 70, 20, 40, 60, 80, 35]:
    root = insert(root, k)
print(list(inorder(root)))
print(level_order(root), level_order(None))

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

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

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

import heapq


def kth_largest(nums: list[int], k: int) -> int:
    if not 1 <= k <= len(nums):
        raise ValueError("k out of range")
    heap: list[int] = []                   # min-heap of the k largest so far
    for x in nums:
        heapq.heappush(heap, x)
        if len(heap) > k:
            heapq.heappop(heap)            # drop the smallest
    return heap[0]

# Library one-liner, also O(n log k):  heapq.nlargest(k, nums)[-1]

Edge case ও ফলো-আপ: heapq সবসময় min-heap — heap[0] সবচেয়ে ছোট। দীর্ঘদিন max-heap-এর প্রচলিত কৌশল ছিল মান ঋণাত্মক করে রাখা (-x); Python 3.14-এ heapq.heappush_max-এর মতো max-heap ফাংশনও যোগ হয়েছে — তবে অনলাইন জাজে পুরোনো সংস্করণ থাকতে পারে, তাই দুটোই জানুন। k অবৈধ হলে স্পষ্ট ValueError — নীরবে ভুল উত্তর নয়। ডুপ্লিকেট গোনা হবে কি না ([3, 3, 2], k = 2 → 3 নাকি 2?) জিজ্ঞেস করুন। ফলো-আপ: সবচেয়ে ঘন ঘন আসা k টি শব্দ — Counter(words).most_common(k), আর তার ভেতরের খরচ।

সমস্যা ১২ · ঘোরানো সাজানো list-এ সার্চ (মাঝারি)

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

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

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

from bisect import bisect_left


def search_rotated(a: list[int], target: int) -> int:
    """Index of target in a rotated sorted list of distinct values, or -1."""
    lo, hi = 0, len(a) - 1
    while lo <= hi:
        mid = (lo + hi) // 2           # Python int never overflows
        if a[mid] == target:
            return mid
        if a[lo] <= a[mid]:            # left half is sorted
            if a[lo] <= target < a[mid]:
                hi = mid - 1
            else:
                lo = mid + 1
        else:                          # right half is sorted
            if a[mid] < target <= a[hi]:
                lo = mid + 1
            else:
                hi = mid - 1
    return -1


def index_of(sorted_a: list[int], x: int) -> int:   # plain sorted list: use bisect
    i = bisect_left(sorted_a, x)
    return i if i < len(sorted_a) and sorted_a[i] == x else -1


a = [4, 5, 6, 7, 0, 1, 2]
print([search_rotated(a, t) for t in (0, 4, 2, 7, 3)], search_rotated([], 1), search_rotated([1], 1))
print(index_of([0, 1, 2, 4, 5, 6, 7], 5), index_of([0, 1, 2], 3))

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

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

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

from functools import cache


@cache
def climb(n: int) -> int:              # 1 or 2 steps at a time
    if n <= 1:
        return 1
    return climb(n - 1) + climb(n - 2)


def min_coins(coins: list[int], amount: int) -> int:
    """Fewest coins that make amount, or -1 (bottom-up DP)."""
    INF = amount + 1                   # larger than any real answer
    dp = [0] + [INF] * amount
    for x in range(1, amount + 1):
        for c in coins:
            if c <= x:
                dp[x] = min(dp[x], dp[x - c] + 1)
    return -1 if dp[amount] == INF else dp[amount]


print("stairs:", climb(1), climb(2), climb(5), climb(50))
print("coins: ", min_coins([1, 3, 4], 6), min_coins([2], 3), min_coins([1, 2, 5], 11), min_coins([7], 0))
print(climb.cache_info())

৬ · Python ডিজাইন সমস্যা — LRU cache, decorator, context manager, generator

এখানে অ্যালগরিদম ছোট, কিন্তু ভাষার জ্ঞান গভীরভাবে যাচাই হয়: কোন collections টাইপ কোন কাজে, closure, exception কীভাবে ছড়ায়, আর lazy মূল্যায়ন। রিভিশনের জন্য: পর্ব ২০ · closure, পর্ব ২৪ · exception, পর্ব ৩০ · dunder method, পর্ব ৩২ · dataclass, পর্ব ৩৪ · generator, পর্ব ৩৫ · decorator, পর্ব ৩৬ · context manager, পর্ব ৩৮ · functools.

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

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

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

পদ্ধতি: দুটি চাহিদা — key দিয়ে দ্রুত খোঁজা (hash), আর ব্যবহারের ক্রম, যেখানে যেকোনো key O(1)-এ “সবচেয়ে নতুন” প্রান্তে সরানো যায়। OrderedDict ঠিক এই দুটি একসাথে দেয়: ভেতরে dict আর একটি doubly linked list. move_to_end(key) আর popitem(last=False) দুটোই O(1).

from collections import OrderedDict


class LRUCache:
    def __init__(self, capacity: int) -> None:
        self.capacity = capacity
        self._data: OrderedDict[int, int] = OrderedDict()   # oldest first

    def get(self, key: int) -> int | None:
        if key not in self._data:
            return None
        self._data.move_to_end(key)            # now the most recent, O(1)
        return self._data[key]

    def put(self, key: int, value: int) -> None:
        if self.capacity <= 0:
            return
        self._data[key] = value
        self._data.move_to_end(key)
        if len(self._data) > self.capacity:
            self._data.popitem(last=False)     # evict the least recent, O(1)


c = LRUCache(2)
c.put(1, 10)
c.put(2, 20)
print(c.get(1), end=" ")                       # 10; key 1 is now most recent
c.put(3, 30)                                   # evicts key 2
print(c.get(2), c.get(3), end=" ")
c.put(1, 11)
c.put(4, 40)                                   # evicts key 3
print(c.get(1), c.get(3), c.get(4))

সমস্যা ১৫ · @retry আর @timer decorator (মাঝারি)

প্রশ্ন: নেটওয়ার্কের ডাক মাঝে মাঝে ব্যর্থ হয়। একটি @retry(times=3) decorator লিখুন, যা নির্দিষ্ট exception হলে ফাংশনটি আবার চেষ্টা করে; শেষ চেষ্টাও ব্যর্থ হলে আসল exception বাইরে যায়।

জিজ্ঞেস করে নিন: কোন কোন exception-এ আবার চেষ্টা হবে — সব, নাকি শুধু নেটওয়ার্কের? চেষ্টার মাঝে অপেক্ষা (backoff) লাগবে? ফাংশনের নাম ও docstring অটুট থাকতে হবে তো?

পদ্ধতি: argument-সহ decorator তিন স্তরের: retry(3) একটি decorator ফেরত দেয়, সেই decorator ফাংশন নিয়ে wrapper ফেরত দেয়। wrapper *args, **kwargs নিয়ে মূল ফাংশনকে হুবহু পাঠায়; functools.wraps নাম ও docstring কপি করে (পর্ব ৩৫)।

import functools


def retry(times: int, on: tuple[type[Exception], ...] = (ConnectionError,)):
    """Decorator factory: call the function up to `times` times."""
    def decorate(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except on as e:
                    print(f"attempt {attempt}: {e}")
                    if attempt == times:
                        raise                  # give up: re-raise the last error
        return wrapper
    return decorate


replies = iter([None, None, 121.5])            # fake network: fails twice


@retry(times=3)
def fetch_rate(currency: str) -> float:
    rate = next(replies)
    if rate is None:
        raise ConnectionError(f"{currency}: timeout")
    return rate


print(fetch_rate("USD"), fetch_rate.__name__)

সমস্যা ১৬ · Transaction context manager — সব হবে, নয়তো কিছুই না (মাঝারি)

প্রশ্ন: wallet-এর টাকা পাঠানোয় দুটি ধাপ: একজনের থেকে কাটা, আরেকজনকে দেওয়া। মাঝপথে ভুল হলে আগের অবস্থায় ফিরতে হবে (rollback). একটি with transaction(accounts): context manager লিখুন।

জিজ্ঞেস করে নিন: ভুল হলে exception কি বাইরে যাবে, নাকি চাপা পড়বে? (বাইরে যাবে — নীরবে ব্যর্থতা সবচেয়ে বিপজ্জনক।) ডেটা কত বড় — পুরো কপি রাখা সম্ভব?

পদ্ধতি: contextlib.contextmanager দিয়ে একটি generator: yield-এর আগের অংশ __enter__, পরের অংশ __exit__. with-ব্লকে exception হলে সেটি yield-এর জায়গাতেই ওঠে, তাই try/except দিয়ে ধরে rollback করে আবার raise.

from contextlib import contextmanager


@contextmanager
def transaction(accounts: dict[str, int]):
    snapshot = dict(accounts)              # copy taken on enter
    try:
        yield accounts
    except Exception:
        accounts.clear()
        accounts.update(snapshot)          # rollback on any error
        raise                              # never swallow the error


def transfer(acc: dict[str, int], src: str, dst: str, amount: int) -> None:
    acc[src] -= amount                     # step 1
    if acc[src] < 0:
        raise ValueError(f"{src}: insufficient balance")
    acc[dst] += amount                     # step 2


wallet = {"rahim": 500, "karim": 100}
with transaction(wallet):
    transfer(wallet, "rahim", "karim", 200)
print(wallet)
try:
    with transaction(wallet):
        transfer(wallet, "karim", "rahim", 900)
except ValueError as e:
    print("failed:", e)
print(wallet)

সমস্যা ১৭ · Generator pipeline — বড় লগ ফাইল এক সারি করে (মাঝারি)

প্রশ্ন: কয়েক GB-এর একটি লেনদেনের লগ ফাইল আছে। মেমরিতে পুরো ফাইল না এনে প্রতিটি প্রোভাইডারের সফল লেনদেনের মোট বের করুন। মন্তব্যের লাইন আর ভাঙা সারি বাদ যাবে।

জিজ্ঞেস করে নিন: লাইনের format কী? ভাঙা সারি কী করব — বাদ, নাকি লগ করে বাদ? ফল কি একবারই লাগবে, নাকি একাধিকবার পড়তে হবে?

পদ্ধতি: ছোট ছোট generator ধাপের শিকল — প্রতিটি একটি করে সারি নেয়, প্রক্রিয়া করে, পরের ধাপে দেয়। পুরো pipeline-এ একসাথে মাত্র একটি সারি মেমরিতে থাকে: মেমরি O(1), সময় O(n). প্রতিটি ধাপ আলাদাভাবে test করা যায় — এটাই lazy evaluation-এর সৌন্দর্য।

from collections.abc import Iterable, Iterator

LOG = """2026-10-01 bKash 500 OK
2026-10-01 Nagad 200 FAIL
# a comment line
2026-10-02 bKash 1200 OK
broken line
2026-10-03 Nagad 700 OK"""

Row = tuple[str, int, str]


def read_lines(text: str) -> Iterator[str]:
    for line in text.splitlines():     # an open file works the same way
        yield line.strip()


def parse(lines: Iterable[str]) -> Iterator[Row]:
    for line in lines:
        parts = line.split()
        if line.startswith("#") or len(parts) != 4:
            continue                   # skip comments and broken rows
        _, provider, amount, status = parts
        yield provider, int(amount), status


def only_ok(rows: Iterable[Row]) -> Iterator[Row]:
    return (row for row in rows if row[2] == "OK")


pipeline = only_ok(parse(read_lines(LOG)))     # nothing has run yet
print(next(pipeline))                          # pulls just enough lines
totals: dict[str, int] = {}
for provider, amount, _ in pipeline:           # the rest, one row at a time
    totals[provider] = totals.get(provider, 0) + amount
print(totals)

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

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

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

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

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

• জোরে ভাবুন: “প্রথমে brute force ভাবছি… এটা O(n²), n যদি এক লাখ হয় তাহলে ধীর… তাই dict ভাবছি।” ইন্টারভিউয়ার আপনার পথ দেখতে পেলে সাহায্যও করতে পারেন।
• প্রশ্ন করুন, ধরে নেবেন না: “ইনপুট কি সাজানো?”, “খালি list আসতে পারে?”, “বাংলা text আসবে?” — এগুলো দুর্বলতা নয়, পেশাদারিত্ব।
• Hint-কে উপহার ভাবুন: ইন্টারভিউয়ার “যদি list-টা সাজানো থাকত?” বললে সেটা একটা দরজা। ধন্যবাদ দিয়ে ধরুন, আর বলুন hint থেকে কী বুঝলেন।
• ভুল স্বীকার করুন, দ্রুত: dry run-এ নিজের বাগ ধরলে সাথে সাথে বলুন। নিজের ভুল নিজে ধরা ইন্টারভিউতে খুব ইতিবাচক সংকেত।
• না জানলে সৎ থাকুন: “asyncio-র TaskGroup নিয়ে বড় কাজ করিনি, তবে যতটুকু জানি…” — বানিয়ে বলা অভিজ্ঞ ইন্টারভিউয়ার সাথে সাথে ধরে ফেলেন।

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

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

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

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

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

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

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

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

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

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

• সমাধান দেখার আগে নিজে অন্তত ২০ মিনিট চেষ্টা করেছি, আর খাতায় পদ্ধতি লিখেছি
• AI-এর বলা জটিলতা নিজে হিসাব করে মিলিয়েছি — AI প্রায়ই in, pop(0) বা slicing-এর লুকানো O(n) খরচ বাদ দেয়
• AI-এর কোড নিজের edge case-এ চালিয়েছি — খালি ইনপুট, ডুপ্লিকেট, বাংলা text
• AI-এর কোডে mutable default, alias, দুবার পড়া generator বা অপ্রয়োজনীয় কপি আছে কি না নিজে খুঁজেছি
• একদিন পরে AI ছাড়া একই সমস্যা আবার শূন্য থেকে সমাধান করতে পেরেছি
• সমাধানটি অন্য কাউকে (বা নিজেকে, জোরে) পাঁচ মিনিটে ব্যাখ্যা করতে পারি

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

এটি ৮টি মডিউল আর ৫৫টি পর্বের এই কোর্সের শেষ পর্ব। একবার পেছনে তাকান। পর্ব ০১-এ প্রশ্ন ছিল, “Python কেন?” পর্ব ০৪-এ লিখেছিলেন প্রথম print, আর পর্ব ০৫-এ দেখেছিলেন Python আপনার কোড কীভাবে bytecode বানিয়ে চালায়। আজ আপনি একটি LRU cache-এর জন্য ঠিক data structure বাছতে পারেন, mutable default-এর ফাঁদ ব্যাখ্যা করতে পারেন, GIL নিয়ে হালনাগাদ উত্তর দিতে পারেন, আর একটি অচেনা সমস্যাকে সাত ধাপে ভেঙে সমাধান করতে পারেন। আন্তরিক অভিনন্দন — পুরো Python কোর্স শেষ করা সত্যিই বড় অর্জন।

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

• নাম, object, mutability আর alias দিয়ে Python-এর মেমরির ছবিটা নিজের ভাষায় ব্যাখ্যা করতে।
• list, tuple, dict, set, comprehension আর collections দিয়ে কম কোডে নির্ভুল সমাধান লিখতে — আর প্রতিটির খরচ বলতে।
• module, package, virtual environment, exception, ফাইল ও JSON দিয়ে বড় প্রোগ্রাম গোছাতে।
• class, dunder method, dataclass, Protocol, generator, decorator আর context manager দিয়ে Pythonic ডিজাইন করতে।
• type hint, pytest, logging, concurrency, asyncio আর profiling দিয়ে পেশাদার মানের একটি প্রজেক্ট দাঁড় করাতে।
• AI-এর লেখা Python কোড যাচাই করতে — আর দরকারে তার ভুল ধরতে।

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

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

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

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

এরপর কোন পথে

ব্যাকএন্ড বা বড় সিস্টেমের দিকে যেতে চাইলে System Design, আর ডেটার দিকে Data Science কোর্সও দেখতে পারেন।