Tech Interview 101 : DSA to System Design for Working Professionals - Live

Class 1: Time & Space Complexity

• Introduction to algorithm analysis, efficiency, and Big-O notation for time complexity

• Bitwise Operators with practical examples (swapping numbers, checking even/odd)

• Number System basics: binary, decimal, octal, hexadecimal, and base conversions

Class 2: Mathematics

• Prime numbers and efficient checking methods

• Sieve of Eratosthenes for generating primes

• GCD & LCM using Euclidean Algorithm with array-based applications

• Examples: fractions, modular arithmetic, and related practice problems

Class 3: Array I

• Array basics, traversal, insertion, deletion, Second Max, Leaders

• Kadanes Algorithm for Maximum Subarray Sum, Buy-Sell Stock problem

• Array rotations using Juggling Algorithm, Reversal method, and examples

Class 4: Array II

• Majority Element using Boyer Moore Voting Algorithm

• Subarrays and Subsequences with Prefix & Suffix arrays

• Practice problems for sum, product, and sliding window subarrays

Class 5: Array III

• Two Pointers technique for pair/triplet sum problems

• Dutch National Flag Algorithm for sorting 0, 1, 2

• Sliding Window problems like Maximum Sum Subarray and Longest Substring

Class 6: Hashing

• Introduction to hash tables, hash functions, and collision handling

• Implementation using STL (unordered_map / unordered_set)

• Practice problems: frequency counts, subarray sums, and pattern-based challenges

Class 7: Recursion

• Basics of recursion, stack usage, and importance of base cases

• Examples: Factorial, Fibonacci Sequence

• Tower of Hanoi and introduction to backtracking concepts

Class 8: Searching

• Linear Search: concept, implementation, and complexity analysis

• Binary Search: iterative & recursive implementations

• Applications: rotated arrays, floor/ceiling search problems

Class 9: Sorting

• Bubble, Selection, and Insertion Sort: comparisons and use cases

• Merge Sort and Quick Sort for efficient sorting

• Conceptual understanding of Cyclic Sort and Shell Sort

Class 10: Matrix

• Matrix traversal: row-wise, column-wise, spiral order

• Matrix rotation, transpose, and binary search in matrix

• Directional traversals and problem-solving exercises

Class 11: Linked List I

• Singly, Doubly, and Circular Linked List basics and operations

• Finding middle element, reversing linked lists, intersection points

• Cycle detection using Floyds Algorithm

Class 12: Linked List II

• Finding length and starting point of a cycle

• LRU Cache implementation using linked list and hashing

• Merge K Sorted Lists and optimization approaches

Class 13: Stack & Queue I

• Stack concepts (LIFO), implementation using array & linked list

• Queue concepts (FIFO), Circular Queue, and Deque

• Applications: expression evaluation, balanced parentheses, undo-redo

Class 14: Stack & Queue II

• Practice problems: Next Greater Element, Sliding Window Maximum

• Stack using Queue, Queue using Stack

• Optimization and problem-solving exercises

Class 15: Backtracking I

• Generating all permutations of array or string

• Generating combinations and subsets using recursion

• Backtracking exercises to explore recursive tree structures

Class 16: Backtracking II

• Rat in a Maze problem

• N-Queen problem with pruning and recursion

• Valid Sudoku solver using backtracking

Class 17: Trees I

• Binary Tree basics, types, and representations (array & linked)

• Traversals: Preorder, Inorder, Postorder

• Practice problems: height, node count, sum of nodes

Class 18: Trees II

• Binary Search Tree (BST): insertion, deletion, and search

• Inorder predecessor & successor

• BST practice problems and path sum exercises

Class 19: Trees III

• Heap concepts: Min Heap & Max Heap

• Heapify, insertion, and deletion operations

• Priority Queue applications and problems

Class 20: Graph I

• Graph representation: adjacency list & matrix

• DFS & BFS traversals

• Problems: connected components, reachability, simple cycle detection

Class 21: Graph II

• Cycle detection in directed & undirected graphs

• DAGs and Topological Sort using DFS & Kahns Algorithm

• Graph problems: scheduling and dependency resolution

Class 22: Graph III

• Shortest Path algorithms: Dijkstras Algorithm

• Multi-source BFS & Flood Fill

• Course scheduling and real-life dependency examples

Class 23: Greedy + DP Basics

• Fractional Knapsack and Coin Change (Greedy)

• Activity Selection (N meetings in a room)

• 0 - 1 Knapsack & Subset Sum problems

Class 24: Advanced Dynamic Programming

• Unbounded Knapsack & Coin Change (DP)

• Longest Common Subsequence (LCS) & Longest Palindromic Subsequence (LPS)

• Matrix Chain Multiplication (MCM) & Palindrome Partitioning

OOP Fundamentals

• OOP principles: Classes, objects, encapsulation, inheritance, and polymorphism

• Advanced OOP concepts: Operator overloading, association, and composition

Design Principles & Patterns

• SOLID principles and key design patterns: Strategy, Observer, Factory, Singleton, and more

System Design Basics

• Introduction to system design, client-server architecture, and scaling strategies

• Key components: DNS, load balancers, and databases (relational and non-relational)

Advanced HLD Concepts

• Advanced topics: Database replication, sharding, caching, and queuing systems

• Comprehensive system design framework for real-world problem-solving

It is an interview-centric, high-level course designed to prepare you for System Design rounds, covering both Low-Level and High-Level Design concepts asked in top tech companies.