- Lecture 1: Time Complexities Big-O, Omega and Theta, Loops Nested Loops and Several Connections to Series and Sequences
- Lecture 2: Time Complexity II - Functions, Recursion and Recursive Program Analysis
- Project: Simulations through mathematical modeling.
In Collaboration with Information Technology University (ITU)
Who can join?
- Graduates preparing for technical interviews for engineering roles at their dream organization
- BS (CS/SE/AI/Data Science) students who have completed at least 2 years of study and want to
- get an unfair advantage in programming competitions
- secure internships at the best companies
- secure summer program scholarships at prestigious foreign universities
- Mid-career engineers looking to level up their career
Acing the coding interview at the organization of your dreams requires a specific training routine. This course takes you through the steps to develop the foundational skills, provides the regular routine of solving a wide variety of problems to develop a creative problem-solving mindset, and equips you with the skills and confidence to effectively analyse new problems and design efficient solutions.
About The Course
Cracking the Coding Interview is a comprehensive, interview-focused course which guides students through core computer science fundamentals including data understanding, algorithm efficiency, and effective problem-solving strategies.The course covers essential topics such as arrays, strings, stacks, queues, STL, recursion, dynamic programming, graphs, greedy algorithms, priority queues, and dynamic data structures like linked lists, hash tables, and binary trees. Learners practice with 150+ LeetCode problems, gaining hands-on experience in solution space exploration and optimization. In addition, the course strengthens interview readiness through object-oriented programming, databases, operating systems (threads and locks), theory of computation, and quantitative and analytical problem solving equipping participants with both the technical depth and confidence required to succeed in real-world technical interviews.
Course Outline
Month 1: Programming Fundamentals and System Design Foundation
Week 1: Think Like a Software Engineer
Week 2: Master Data Before Algorithms
- Lecture 1: Arrays, Strings, 2D Arrays, Searching, Convolutions and Image Processing
- Lecture 2: Array-Based Problem Solving: Sorting, Segregation and their several Applications, Divide and Conquer.
- Project: Snakes & Ladders
Week 3: Pointers & Memory Management in Dynamic Systems
- Lecture 1: Pointers, Stack vs Heap, Dynamic Memory, Challenges with Pointers (Memory Leakage, Dangling Pointer, Wild Pointer and several errors)
- Lecture 2: Pointers and its Several Types, void pointer, function pointers and C's Polymorphism)
- Project: Building Naive Based AI System - Gomoku (Human vs Human and Human vs AI)
Week 4: Structs and I/Os Based Systems
- Lecture 1: Structs, Enums, Data Handling, Student Management System
- Lecture 2: File Handling, Function Pointer Dispatch on structs, Handling Binary File system
- Project: Procedural and C's Polymorphism Based - Chess Game
Month 2: OOP & Design Patterns
Week 5: Classes & OOP Basics
- Class Structure, Constructors, Destructors, Static attibutes/function and Singleton Design Pattern, Proxy Design Patterns and Smart Pointers
- Project: Polynomial Calculator and Text Editor
Week 6: Operator Overloading and Usage of STL
- Arithmetic & Advanced Overloading specially operator(), [], several details of operator overloading. How operator overloading helps in STL containers usages - connection to set, multiset, priority_queue data structure.
- Project: Cryptography Based - Huge Integer Library
Week 7: Relationships & STL
- Object Relationships, Composition, Aggregation and Association and its several Applications in real life and Interviews
- Project: LUDO Game
Week 8: Inheritance & Polymorphism
- Class Level Relationship, The power of Inheritance - Integration, The Need of Polymorphism, How Polymorphism works using V-Tables.
- Project: Building Chess (OOP Version)
Month 3: Data Structures & STL
Week 9: Stack, Queue, Vector
- Implementation of vector, deque and based on that making adapters data structures (stack and queues).
- Several Applications of Stacks, Queues and Vector Data Structures.
- Solving atleast 20-25 LeetCode Problems live coding with LLMs help.
- How to work without LLMs vs How to use LLMs in Interviews?
Week 10: Linked Lists
- Singly, Doubly, and Circular linked lists with applications.
- Graphs and Its Several Applications.
- Project: TextEditor in data structures setting, Twitter, Designing Browser History, LFU Cache, and similar several LeetCode Problems.
Week 11: Trees
- Binary Trees: BST, AVL, Heaps, and Tries. Several Traversal (Inorder, Preorder, Postorder), Breadth First Traversals and several Applications on trees.
- Solving 25+ LeetCode Problems related to Binary Trees.
- Connection with set and multiset, map and multimap data structures in STL - and 25+ LeetCode Problems.
Week 12: Hashing
- Hash tables, collision handling, and real-world use cases.
- Unordered_map and Unordered_multimap data structures and several applications.
Month 4: Algorithms
Week 13: Divide and Conquer – Quick Sort
- Introduction to Divide and
- QuickSort and Divide & Conquer basics.
- Partitioning using left/right pivot selection.
- Best, worst, and skewed case analysis.
- Randomized and deterministic QuickSort.
- Recurrence analysis of QuickSort.
- Median of Medians (linear-time median finding).
- QuickSelect for Kth smallest element. LeetCode Practice: LeetCode Divide & Conquer
Week 14: Dynamic Programming
- Shortest path in DAG and longest path connection.
- Catalan numbers and applications (BST, parenthesization).
- Top-down vs bottom-up DP (memoization & tabulation).
- Fibonacci using Dynamic Programming.
- Kadane’s Algorithm (max subarray / stock problem).
- Longest Increasing Subsequence (LIS) and DAG relation.
- Recurrence formulation and bottom-up solutions.
- Solution reconstruction and complexity analysis. LeetCode Practice: LeetCode DP Problems
Week 15: Greedy Algorithms
- Shortest path in DAG, Catalan numbers, and Fibonacci using DP.
- Top-down vs bottom-up DP with recurrence formulation.
- Kadane’s Algorithm (max subarray) and stock problem.
- Longest Increasing Subsequence (LIS), DAG relation, and solution reconstruction. LeetCode Practice: LeetCode Greedy Problems
Week 16: Graph Algorithms
- Introduction to graphs, representations (Adjacency List & Matrix).
- Depth First Search (DFS), Breadth First Search (BFS) and their applications.
- Topological Sorting and Directed Acyclic Graphs (DAG).
- Strongly Connected Components (Kosaraju’s Algorithm).
- Shortest Path Algorithms: BFS (unweighted), Dijkstra, Bellman-Ford.
- Minimum Spanning Trees (Prim’s and Kruskal’s Algorithms).
- Advanced topics: Universal Sink, Reachability, and Graph traversal techniques.
- All-Pairs Shortest Path (APSP) and Single Source Shortest Path (SSSP). LeetCode Practice: Linked List, Binary Tree, Hash Table
Month 5: Operating System, Database & Designs
Week 17: Operating Systems
Processes, scheduling, threads, synchronization.
Week 18: Memory & File Systems
Memory management and file handling systems.
Week 19: Databases (SQL)
SQL, indexing, transactions, and database design.
Week 20: System Design
Scalable systems, architecture, and design patterns.
Month 6: Mock Interviews
Week 21: DSA Mock Interviews
Practice real interview-style coding problems.
Week 22: System Design Interviews
Mock interviews focused on system design.
Week 23: Behavioural Preparation
Communication, HR questions, and STAR method.
Week 24: Final Mock & Launch
Full interview simulation and final preparation.
Recorded Lectures
With lifetime access to our lecture content,
you can revisit and refresh your concepts at your convenience.
Hello 👋
Can we help you?
Need more information about Cracking the Coding Interview
Can we help you?
Need more information about Cracking the Coding Interview
Open chat