{
adam
coding
}
~/home
~/about
~/projects
~/blog
~/tracker
~/uses
~/contact
☀️
~/home
~/about
~/projects
~/blog
~/tracker
~/uses
~/contact
☀️
DSA Tracker
0%
Apr 07 →
Jul 20, 2026
on track
Week 1: Basics & Foundations
Apr 7-13 | Phase 1: Foundation
Pre-Course: Python Toolkit (Read Before Day 1)
30 mins
📚 Learning
collections.Counter — frequency counts
collections.defaultdict — dict with default values
collections.deque — O(1) append/pop from both ends
heapq — min-heap: heappush, heappop, heapify, nlargest
bisect.bisect_left / bisect_right — binary search on sorted list
itertools.combinations / permutations
enumerate(), zip(), any(), all()
sorted(lst, key=...) and lst.sort(reverse=True)
Interview pattern: always solve brute-force first, then optimize
🔄 Review
Review the Priority Index and study plan
📝 Reflection / Notes:
Day 1-2: List Comprehensions & Arrays Basics
2-3 hours
📚 Learning
Python list comprehensions
Understand array slicing and indexing
Array time complexity
Two Sum: implement brute-force O(n²) nested loops, then O(n) hash map
🔗 LeetCode
1. Two Sum
Easy
9. Palindrome Number
Easy
🎯 HackerRank
List Comprehensions
Easy
2D Arrays - DS
Easy
📝 Reflection / Notes:
Day 3-4: Two Pointers & Sliding Window
3-4 hours
📚 Learning
Two pointer technique concept
Sliding window pattern
When to use which technique
Compare brute-force O(n²) vs two-pointer O(n) on sorted input
🔗 LeetCode
167. Two Sum II
Easy
125. Valid Palindrome
Easy
3. Longest Substring Without Repeating Characters
Medium
🎯 HackerRank
Simple Array Sum
Easy
Solve Me First
Easy
📝 Reflection / Notes:
Day 5-6: Hash Maps & Dictionaries
2-3 hours
📚 Learning
Hash map fundamentals
dict.get(), dict.items(), Counter
Hash collisions concept
Valid Anagram: compare O(n log n) sorting vs O(n) Counter approach
🔗 LeetCode
242. Valid Anagram
Easy
205. Isomorphic Strings
Easy
49. Group Anagrams
Medium
🎯 HackerRank
Counting Valleys
Easy
Ransom Note
Easy
📝 Reflection / Notes:
Day 7: Big O Notation & Review
2-3 hours
📚 Learning
What Big O measures: worst-case growth rate
O(1) — constant time (hash lookup, array index)
O(log n) — logarithmic (binary search, balanced BST)
O(n) — linear (single loop, linear search)
O(n log n) — linearithmic (merge sort, Tim sort)
O(n²) — quadratic (nested loops, bubble sort)
O(2^n) and O(n!) — exponential/factorial (subsets, permutations)
Analysing loops: single, nested, sequential
Analysing recursion with recurrence relations
Space complexity: auxiliary vs input space
Big O of Python built-ins (list, dict, set ops)
🔄 Review
Analyse: Two Sum — what is the brute-force vs hash map complexity?
Analyse: Valid Palindrome — time and space?
Analyse: Valid Anagram — compare sorting vs Counter approach
Analyse: Longest Substring Without Repeating Characters — why is sliding window O(n)?
📝 Reflection / Notes: