🧮 शाळेच्या पद्धतीने DSA शिका

# the 60-second wow — every cost, measured:
git clone https://github.com/BaluRaut/learn-dsa-school.git && cd learn-dsa-school
python3 dsa/demo.py                # Big-O timed, every container and every walk with its step count
python3 dsa/test_dsa.py            # the smoke test: 12 checks over every structure and recipe

तुम्हाला काय दिसायला हवे (छाटलेले — यश असे दिसते):

── Big-O — how the work grows when the school doubles (lesson 01)
   n=  1,000: linear   1,000 steps   N.NNN ms · binary 10 steps  N.NNN ms · hash 1 step N.NNN ms
   n= 10,000: linear  10,000 steps   N.NNN ms · binary 14 steps  N.NNN ms · hash 1 step N.NNN ms
   n=100,000: linear 100,000 steps   N.NNN ms · binary 17 steps  N.NNN ms · hash 1 step N.NNN ms
   ×10 pupils → linear ×10 (O(n)), binary +3 steps (O(log n)), hash the same (O(1)) — the shape is the whole subject

── Arrays — the row of lockers: jump straight to locker 17, but inserting at the front shifts everyone (lesson 02)
   lockers[17] = 17  (one step, whatever the row length)
   insert at the FRONT of 2,000,000: N.NNN ms (everyone shifts) · append at the BACK: N.NNN ms
   sliding window: best 3 consecutive days of [3, 8, 2, 9, 7, 1, 6, 4] → sum 19 starting at day 1
   two pointers: which two of [1, 2, 3, 4, 6, 7, 8, 9] sum to 13? → indices (3, 7)

── Linked lists — the treasure hunt: each note says where the next one is (lesson 03)
   notes in order: ['Aishwarya', 'Katrina', 'Dipika', 'Meera', 'Rohan']   (push_front is O(1): a new note pointing at the old first)
   find 'Katrina': followed 2 notes · find 'Zoya': -1 (walked all 5)
   reversed in place: ['Rohan', 'Meera', 'Dipika', 'Katrina', 'Aishwarya']

── Stacks and queues — the tray pile (LIFO) and the lunch line (FIFO) (lesson 04)
   pile: put 1,2,3 → take: tray 3, tray 2
   line: join Aishwarya, Katrina, Dipika → serve: Aishwarya, Katrina
   brackets with a stack: '(a[b]{c})' → True · '(a[b)]' → False

── Hash maps — pigeonholes by name: hash(name) says which box, so a lookup is O(1) (lesson 05)
   8 pupils filed · boxes grew to 16 · collisions on the way: 2 · Dipika → 3A · 'Zed' in map? False
   counting with a dict: {'the': 3, 'cat': 1, 'sat': 1, 'on': 1, 'mat': 1, 'end': 1}  (one pass, O(n))

── Recursion — the head asks the deputy, who asks the teachers … (lesson 06)
   5! = 120 — the asking went 5 levels deep before the base case answered
   fib(25): asked 242,785 times without a board · 49 times with one (memoisation, lesson 11)

── Sorting — lining up the class by height: n² walks vs n log n splits (lesson 07)
   bubble    1,997,047 comparisons   N.NNN ms
   insertion   985,773 comparisons    N.NNN ms
   merge        19,384 comparisons     N.NNN ms
   quick        13,248 comparisons     N.NNN ms
   nearly sorted: insertion needs 1,999 comparisons, bubble 1,999 — the input shape matters
   Python's sorted() (Timsort) in N.NNN ms — at work you call it; here you know why it is fast

── Binary search — the register is sorted, so open it in the middle (lesson 08)
   50,000 pupils, find #823853: linear looked at 41,235 · binary at 15  (log2(50,000) ≈ 15.6)
   search on the answer: the smallest locker that fits 8 bags of 30 kg into 3 lockers → 90 kg (binary search over capacities 1–240)

── Trees — the catalogue drawer (BST) and the podium (heap) (lesson 09)
   balanced insert order: height 4, search(43) looked at 4 cards · in-order walk = sorted: [6, 12, 18, 25, 31, 37]…
   sorted insert order:   height 11 — a list in disguise; search(11) looked at 11 cards (why balanced trees exist)
   heap of 100 m times: top 10.8 · pop → 10.8, 11.4, 12.1  (each fix-up O(log n))

── Graphs — the corridor map: BFS floods by hops, DFS follows one corridor, Dijkstra measures (lesson 10)
   BFS from office (hops): {'office': 0, 'hall': 1, 'lab': 2, 'library': 2, 'gym': 3, 'field': 4}
   DFS from office (order): ['office', 'hall', 'lab', 'gym', 'library', 'field']
   Dijkstra from office (metres): {'office': 0, 'hall': 20, 'lab': 50, 'library': 30, 'gym': 65, 'field': 105}  · cycle? True

── Dynamic programming and greedy — remember answers on the board; take the meeting that ends first (lesson 11)
   stairs(10) ways to climb 10 steps by 1s and 2s: 89 · coin_change([1,5,10,25], 63) → 6 coins · coin_change([4,7], 5) → -1
   one room, most meetings: ['chess', 'coding', 'art']  (sort by end time, greedily take what fits)

── Choosing the structure — the question decides (lesson 12)
   jump to the i-th thing                   → array / list                     O(1) index
   add/remove at the front constantly       → linked list or deque             O(1)
   undo, nesting, most-recent-first         → stack                            O(1) push/pop
   first come first served                  → queue                            O(1) both ends
   look something up by name                → hash map / set                   O(1) average
   keep things sorted while adding          → balanced BST / sorted container  O(log n)
   always need the smallest / biggest       → heap (priority queue)            O(log n)
   rooms and corridors, shortest path       → graph + BFS / Dijkstra           O(V + E) / O(E log V)
   overlapping sub-problems                 → dynamic programming              usually O(n) or O(n·m)

✅ the library: know the cost of every container and every walk, and the right one picks itself

🗺️ संपूर्ण चित्र — एक आकृती, पूर्ण कोर्स

संपूर्ण कोर्स एका कॅनव्हासवर. 4K आवृत्तीसाठी क्लिक करा.

🏫 भाग 1 — जागा (धडे 1–6)

एक git ब्रँच = एक कल्पना; ब्रँच 04 मध्ये धडे 01–04 आहेत. लॅब साध्या Python 3 वर चालतात — libraries नाहीत, installs नाहीत.

🚶 भाग 2 — चाली (धडे 7–12)

Algorithms, प्रत्येक साध्या आवृत्तीविरुद्ध मोजलेला, म्हणजे Big-O तुम्हाला सांगितलेले नाही तर तुम्ही पाहिलेले असते.

📐 धड्यांच्या आकृत्या — क्रमांक अनुसरा

प्रत्येक धडा एका क्रमांकित बॉक्स-आणि-बाण आकृतीत — स्वतंत्र पानावरही.