DSA + Competitive Programming

Builds rock-solid C++/Java/Python foundations so you can translate any algorithmic idea into bug-free, compileable code from day one.

• Variables, data types & type conversion across C++/Java/Python
• Operators, operator precedence & bitwise basics
• Conditional statements and nested branching patterns
• Loops: for/while/do-while and loop-invariant thinking
• Functions, parameter passing (value vs reference) & recursion primer
• Arrays and multi-dimensional arrays fundamentals
• Pointers & references in C++ vs object references in Java/Python
• Pass-by-value vs pass-by-reference pitfalls in interviews
• Input/output fast I/O tricks (scanf/cin sync, BufferedReader, sys.stdin)
• Basic OOP: classes, objects, constructors & encapsulation
• Standard Template Library overview: vector, pair, string methods
• Setting up a competitive programming template & code snippets
• Debugging techniques: print debugging, assertions, IDE breakpoints
• Choosing the right language per contest/company (C++ speed vs Python readability)

Trains you to predict and justify algorithm efficiency before writing code, the single most tested interview skill.

• Big-O, Big-Omega and Big-Theta notation formalized
• Best, average & worst case analysis of algorithms
• Analyzing loops: single, nested & dependent loop complexity
• Recurrence relations and the Master Theorem
• Recursion tree method & substitution method for solving recurrences
• Amortized analysis (dynamic arrays, union-find path compression)
• Space complexity analysis: auxiliary vs input space
• Time-space tradeoffs and when to prefer memory over speed
• Comparing common complexity classes: O(1) to O(2^n)
• Reading constraints to reverse-engineer the expected time complexity
• Benchmarking code empirically vs theoretical complexity
• Complexity of STL/collections operations (vector, map, set, priority_queue)
• Common complexity traps: hidden O(n) inside loops, string concatenation costs

Turns arrays, strings and recursive thinking into an intuitive toolkit for solving the majority of easy-to-medium interview questions.

• Array traversal, in-place modification & prefix/suffix sums
• Two-pointer technique for sorted array problems
• Sliding window (fixed & variable size) for subarray problems
• Kadane's algorithm for maximum subarray sum
• Matrix operations: rotation, spiral traversal, transpose
• String manipulation: reversal, palindrome checks, anagram detection
• String pattern matching intro (naive, KMP overview)
• Recursion fundamentals: base case, recursive case, call stack visualization
• Recursion on arrays/strings: permutations & subsets generation
• Backtracking preview via recursive tree pruning
• Divide and conquer paradigm (merge sort perspective)
• In-place array rearrangement (Dutch National Flag, move zeroes)
• Prefix XOR and difference array techniques
• Common interview patterns: Kadane variants, product of array except self

Equips you to pick and implement the optimal search/sort strategy instantly and solve constraint-satisfaction problems via backtracking.

• Linear search vs binary search & binary search on answer technique
• Binary search on rotated & nearly-sorted arrays
• Lower bound / upper bound and STL binary search functions
• Bubble, insertion, selection sort mechanics & stability
• Merge sort: divide-and-conquer implementation & complexity proof
• Quick sort: partition schemes (Lomuto/Hoare) & worst-case analysis
• Counting sort, radix sort & bucket sort for linear-time scenarios
• Custom comparators & sorting objects/pairs in C++/Java/Python
• Backtracking framework: choose-explore-unchoose template
• N-Queens, Sudoku solver & permutations via backtracking
• Subset sum, combination sum & partition problems using backtracking
• Rat in a maze & word search grid backtracking
• Pruning strategies to reduce backtracking search space
• Choosing sort/search algorithm based on constraints & stability needs

Builds fluency with pointer-based and LIFO/FIFO structures that underpin browser history, undo systems and OS scheduling questions.

• Singly, doubly & circular linked list implementation from scratch
• Reversal of linked lists (iterative, recursive & in groups of k)
• Floyd's cycle detection (slow-fast pointer) & cycle removal
• Merge two/k sorted linked lists & find intersection point
• LRU cache design using doubly linked list + hash map
• Stack implementation via array/linked list & applications
• Balanced parentheses, next greater/smaller element using stacks
• Min stack & stack-based expression evaluation (infix/postfix/prefix)
• Queue, circular queue & deque implementation
• Queue using two stacks and stack using two queues
• Monotonic stack/queue pattern for range problems
• Sliding window maximum using deque
• Implementing an LFU cache & design questions using stacks/queues
• Trapping rain water & largest rectangle in histogram via stacks

Develops O(1)-lookup instincts and hierarchical thinking needed to ace frequency, lookup and tree-traversal interview questions.

• Hash tables: collision handling via chaining & open addressing
• HashMap/HashSet usage patterns & custom hash functions
• Frequency counting, two-sum family & subarray sum problems via hashing
• Binary tree traversals: inorder, preorder, postorder (recursive & iterative)
• Level-order traversal & BFS/DFS on trees
• Tree construction from traversals & serialization/deserialization
• Height, diameter, balanced-tree checks & lowest common ancestor
• Binary Search Tree operations: insert, delete, search & validation
• BST to sorted array conversions & kth smallest/largest element
• Trie (prefix tree) construction for word search & autocomplete
• Segment tree & Fenwick tree (BIT) introduction for range queries
• Morris traversal for O(1) space inorder traversal
• Vertical order & boundary traversal of binary trees
• Tree DP basics: diameter, max path sum using post-order recursion

Gives you the tools to solve top-k, scheduling and median-finding problems in optimal logarithmic time.

• Binary heap structure & array representation (min-heap/max-heap)
• Heapify, build-heap & heap sort implementation
• Priority queue usage in C++ (priority_queue) & Java (PriorityQueue)
• Kth largest/smallest element using heaps
• Top-K frequent elements via heap + hashing
• Merge k sorted lists/arrays using a min-heap
• Median in a data stream using two heaps
• Task scheduling & CPU scheduling simulation with heaps
• Custom comparator heaps for pairs/objects
• Indexed priority queue concept for Dijkstra's optimization
• K-way merge pattern & sliding window median
• Huffman encoding using a min-heap
• When to prefer heaps vs sorting vs balanced BSTs

Prepares you to model real-world networks and solve connectivity, shortest-path and dependency problems that dominate senior-level rounds.

• Graph representations: adjacency list, matrix & edge list tradeoffs
• BFS & DFS traversal, connected components & bipartite check
• Topological sort (Kahn's algorithm & DFS-based) for DAGs
• Cycle detection in directed & undirected graphs
• Dijkstra's & Bellman-Ford shortest paths (with negative edges)
• Floyd-Warshall all-pairs shortest path algorithm
• Minimum Spanning Tree: Prim's & Kruskal's algorithms
• Disjoint Set Union (Union-Find) with path compression & rank
• Strongly connected components: Kosaraju's & Tarjan's algorithms
• Articulation points & bridges in graphs
• Multi-source BFS & 0-1 BFS for weighted-lite graphs
• Graph coloring, flood fill & word ladder style problems
• Network flow basics: max-flow min-cut (Ford-Fulkerson/Edmonds-Karp)
• Modeling grid problems & implicit graphs (islands, mazes, knight moves)

Sharpens optimal-substructure intuition to crack the hardest asked category in FAANG and CP alike: DP and greedy optimization.

• Greedy paradigm: exchange argument & proof of correctness
• Activity selection, interval scheduling & job sequencing
• Fractional knapsack & Huffman coding as greedy problems
• 1D DP: climbing stairs, house robber, coin change patterns
• 2D DP: unique paths, minimum path sum & grid-based DP
• 0/1 Knapsack & subset-sum family of DP problems
• Unbounded knapsack & rod cutting variants
• Longest Common Subsequence, Longest Increasing Subsequence & variants
• Edit distance, string matching & palindrome partitioning DP
• Matrix Chain Multiplication & interval/range DP
• Bitmask DP for subset-based state (TSP, assignment problems)
• Digit DP for counting numbers with constraints
• Tree DP & DP on graphs (DAG shortest/longest path)
• Space optimization of DP: rolling arrays & memoization vs tabulation tradeoffs

Adds low-level bit tricks and specialized data structures that separate top 1% CP performers from average competitors.

• Bitwise operators recap: AND, OR, XOR, NOT, shifts
• Checking, setting, clearing & toggling individual bits
• XOR tricks: single number, missing number & swap without temp
• Counting set bits (Brian Kernighan's algorithm) & bit DP
• Subset generation using bitmasking
• Sparse table for O(1) range minimum/maximum queries
• Segment tree with lazy propagation for range updates
• Fenwick tree (Binary Indexed Tree) for prefix sums & inversions
• Trie-based bitwise maximum XOR pair problems
• Sqrt decomposition & Mo's algorithm for offline range queries
• Number theory essentials: sieve of Eratosthenes, modular exponentiation, modular inverse
• Combinatorics basics: nCr with modulo, Pascal's triangle precomputation
• String algorithms: KMP, Z-function & Rabin-Karp for pattern matching
• Randomized algorithms & hashing tricks (polynomial rolling hash)

Converts topic mastery into contest-day performance with rating strategy, speed practice and mock-interview readiness.

• Reading & decoding problem statements fast (constraints-to-approach mapping)
• Rating-tier strategy & virtual contest practice on the KodPrep platform
• Timed contest strategy: time-boxing & partial-credit approach
• Building a personal template library (fast I/O, DSU, segment tree snippets)
• Debugging under contest pressure: stress testing & brute-force comparison
• Recognizing problem patterns from constraints (n <= 1e5 vs 1e9 signals)
• Mock technical interviews: whiteboard communication & complexity justification
• Company-wise interview pattern research (Amazon, Google, Microsoft, service companies)
• System design vs DSA round balance for full-time SDE interviews
• Curated practice sets for campus placement drives on KodPrep
• Time management across a 90-minute OA/technical round
• Handling edge cases & writing test cases before submitting
• Post-contest upsolving routine & maintaining a mistakes log
• Building consistency: 100-day problem-solving streak planning