နားလည်ထားရမယ့် အချက်
Data Structures & Algorithms (DS&A) ကို interview အတွက် အလေ့အကျင့်ပြုရန် topic တစ်ခုအဖြစ်ပဲ မကြာခဏ သင်ကြားလေ့ရှိပေမယ့် တကယ်တော့ ဒါဟာ ကျွန်တော်တို့နေ့စဉ်သုံးနေတဲ့ feature တိုင်းရဲ့ အောက်ခြေမှာ အလုပ်လုပ်နေတဲ့ engine ပါပဲ — search box တစ်ခုက စာရိုက်နေတုန်း suggestion ပြပေးတဲ့အခါ၊ social feed တစ်ခုက post တွေကို relevance အလိုက် ranking လုပ်တဲ့အခါ၊ cache တစ်ခုက နောက်ဆုံးကြည့်ခဲ့တဲ့ page တွေကို ချက်ချင်းမှတ်ထားပေးတဲ့အခါ၊ အဲဒီနောက်ကွယ်မှာ data structure တစ်ခုနှင့် algorithm တစ်ခုက တကယ့်အလုပ်ကို လုပ်နေတာပါ။ မှားယွင်းတဲ့ ရွေးချယ်မှုတစ်ခု လုပ်မိရင် instant ဖြစ်သင့်တဲ့ feature တစ်ခုဟာ data ကြီးလာလေ လေးလာလေ ဖြစ်သွားမှာဖြစ်ပြီး — naive linear scan တစ်ခုက row 100 မှာ ကောင်းကောင်းအလုပ်လုပ်ပေမယ့် row 10 သန်းမှာတော့ သုံးမရတော့ပါဘူး။ မှန်ကန်တဲ့ ရွေးချယ်မှု — O(1) lookup အတွက် hash map, O(log n) search အတွက် sorted structure, O(log n) ranking အတွက် heap — ကို ရွေးချယ်ရင်တော့ data ဘယ်လောက်ပဲကြီးလာလာ feature ဟာ မြန်ဆန်နေဆဲဖြစ်ပါလိမ့်မယ်။ ဒီ course ဟာ DS&A ကို abstract math အဖြစ်မကြည့်ဘဲ toolbox တစ်ခုအဖြစ် ဆက်ဆံပါမယ် — structure နှင့် algorithm တစ်ခုစီဟာ ပြဿနာပုံစံ အသီးသီးကို ဖြေရှင်းပေးပြီး ဘယ် tool က ဘယ် ပြဿနာနှင့် ကိုက်ညီလဲဆိုတာ သိထားခြင်းဟာ scale ဖြစ်နိုင်တဲ့ code နှင့် production မှာ တိတ်တဆိတ် ပျက်သွားတဲ့ code ကြားက ကွာခြားချက်ဖြစ်ပါတယ်။ ရှေ့ဆက်မယ့် roadmap ကတော့ foundational analysis (Basic) ကနေ core structure များနှင့် classic algorithm များ (Intermediate) ကို ဖြတ်သန်းပြီး၊ advanced technique များ (Advanced) ဆီ ဆက်သွားကာ hands-on Projects သုံးခု — LRU cache, graph pathfinder, Trie-based autocomplete engine — နှင့် သီးသန့် Exercise များနှင့် အဆုံးသတ်ပါမယ်။
လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်
ဒီ course တစ်ခုလုံးမှာ Tutorial Platform ရှိပြီးသား feature တွေရဲ့ နောက်ကွယ်က machinery အတိအကျကို တည်ဆောက်သွားမှာဖြစ်ပါတယ် — slug-to-content lookup အတွက် hash map, search-suggest autocomplete ကို power ပေးတဲ့ Trie, 'related lessons' traverse လုပ်ဖို့ graph, trending content ranking အတွက် heap, hot lesson content အတွက် LRU cache, sorted lesson list အပေါ် binary search, search ranking အတွက် sorting, နှင့် optimal learning path sequence လုပ်ဖို့ dynamic programming။ abstract puzzle တွေအစား၊ သင်လေ့လာမယ့် structure တိုင်းက ဒီ platform ရဲ့ တကယ့်အစိတ်အပိုင်းတစ်ခုနှင့် တိုက်ရိုက်ဆက်စပ်နေပြီး၊ အဆုံးသတ် project သုံးခုက အဲဒီ machinery တွေကို တကယ်တွေ့ရမယ့် tool တွေအဖြစ် ပေါင်းစည်းပေးပါမယ်။
အတူတူ စမ်းရေးကြည့်မယ်
No DS&A knowledge Right DS&A choice
--------------------------------------- ---------------------------------------
Find a lesson by slug: scan all N lessons Find a lesson by slug: hash map lookup
-> O(n), slows down as content grows -> O(1), constant regardless of size
Autocomplete suggestions: scan all titles Autocomplete suggestions: walk a Trie
-> O(n) per keystroke -> O(k), k = length of typed prefix
Find a lesson in a sorted list: scan one by one Find a lesson in a sorted list: binary search
-> O(n) -> O(log n)
Top 10 trending lessons: sort everything Top 10 trending lessons: heap of size 10
-> O(n log n) every time -> O(n log k), k = 10platform task လေးခု (lookup, autocomplete, search, ranking) ကို data structure မှန်ကန်စွာ မရွေးချယ်ရင် O(n) (သို့) ပိုဆိုးတဲ့ cost ရှိပြီး၊ မှန်ကန်တဲ့ structure ရွေးချယ်ရင် O(1)/O(log n)/O(k) ဖြစ်သွားတာကို side-by-side ပြသပေးသည်။၅ မိနစ် စမ်းကြည့်
Diagram ထဲက feature တစ်ခု (ဥပမာ autocomplete) ကို ရွေးပြီး Tutorial Platform မှာ lesson တစ်သန်းရှိလာရင် 'No DS&A knowledge' column ရဲ့ approach ကြောင့် user တွေအတွက် ဘာတွေ မြင်သာစွာ ပျက်သွားနိုင်လဲဆိုတာကို ကိုယ်ပိုင်စကားနှင့် ရေးပါ။
သတိလေးတစ်ချက်
DS&A ကို interview trivia အဖြစ်ပဲ ယူဆပြီး code ရေးတဲ့အခါ list (သို့) dict ကို ရှေးဦးစွာ တွေးမိသလို ရွေးလိုက်ခြင်း — access pattern (lookup, insert, ordered traversal) က ဘယ်လို လိုအပ်သလဲဆိုတာ မစစ်ဆေးဘဲ ရွေးချယ်ခြင်းသည် ကိုက်ညီမှု မရှိနိုင်ပါ။
data နမူနာ အနည်းငယ်နှင့်ပဲ စမ်းသပ်ပြီး structure က 'အလုပ်လုပ်တယ်' လို့ ကောက်ချက်ချခြင်း — N ကြီးလာမှသာ O(n) vs O(1) လို complexity ကွာခြားမှုက အမှန်တကယ် ပြသာနာဖြစ်လာတာကို လျစ်လျူရှုမိခြင်း။
MIT OpenCourseWare — Introduction to Algorithms — Data Structures & Algorithms