Week 1: Introduction to Java Programming
An overview of Java basics, covering syntax, methods, and fundamental concepts in programming.
Day 1: Orientation
Introduction to the course, setting up the development environment, and overview of Java programming.
Day 2: Java Intro
Learn Java syntax, the main method, and fundamental computing principles.
Day 3: Variables and Data Storage
Introduction to variables, primitive data types, and memory storage in Java.
Day 4: Control Flow
Understand and implement conditional statements and loops for controlling program flow.
Day 5: Java Methods
Explore methods: reusability, modifiers, execution flow, and method overloading.
Week 2: Object-Oriented Programming and Collections
Focus on Java object-oriented principles and working with collections.
Day 6: Java Objects
Learn about Java objects and key OOP principles such as Encapsulation, Inheritance, and Polymorphism.
Day 7: String and Array Manipulation
Understand basic string and array operations, reinforcing Week 1's knowledge.
Day 8: Collection I - List, Array, Map, Set
Explore lists, arrays, maps, and sets, focusing on CRUD operations and understanding time complexities.
Day 9: Collection II - Stack, Queue, Heap
Deep dive into stack, queue, and heap data structures and their applications.
Day 10: Practice Session
Build a hands-on project: Develop a hotel management system using Java.
Week 3: Introduction to Data Structure and Algorithms
Focus on Two Pointers, Binary Search, and Linked Lists.
Day 11: Two Pointers - 1
Introduction to two-pointer techniques and their real-world applications.
Day 12: Binary Search - 1
Master binary search algorithms for searching sorted and unsorted data collections.
Day 13: Practice Session
Solve popular interview problems related to two-pointer and binary search techniques.
Day 14: Linked Lists
Learn linked list basics, operations, and solve problems like reversing a linked list.
Day 15: Map & Set
Review map and set data structures with relevant interview questions and problem-solving.
Week 4: Advanced Data Structures
Explore stacks, queues, heaps, and trees, with a focus on interview problems.
Day 16: Stack & Queue
Recap stack and queue operations, and explore algorithmic applications.
Day 17: Heap & Sweeping Line
Understand heaps and the sweeping line algorithm for solving geometric problems.
Day 18: Tree - 1
Introduction to trees and basic tree traversal algorithms.
Day 19: Tree - 2
Deep dive into Binary Search Trees (BSTs) and tree modifications.
Day 20: Practice Session
Solve problems using stack, queue, heap, and tree algorithms.
Week 5: Graphs and Depth-First Search (DFS)
Master graph theory and DFS techniques for solving complex problems.
Day 21: Graph & BFS - 1
Introduction to graph algorithms with breadth-first search (BFS) and level-order traversal.
Day 22: Graph & BFS - 2
Topological sort and shortest path algorithms in simple graphs.
Day 23: Practice Session
Solve graph/tree-related interview problems, applying BFS and DFS techniques.
Day 24: DFS - 1
Learn DFS definitions and techniques, including recursion and backtracking.
Day 25: DFS - 2
Dive into medium-level DFS problems, such as subset generation and word search.
Week 6: Advanced Depth-First Search (DFS)
Introduce DP concepts and solve problems using memorization and bottom-up approaches.
Day 26: DFS - 3
Explore graph-based DFS problems and learn when to choose between DFS and BFS.
Day 27: Practice Session
Solve DFS-related problems, comparing different DFS and BFS solutions.
Day 28: Two Pointers & Binary Search - 2
Learn advanced two-pointer and binary search techniques for partitioning and range queries.
Day 29: DP
Introduction to Dynamic Programming (DP) and problem-solving strategies using both top-down and bottom-up approaches.
Day 30: Practice Session
Solve DP problems, focusing on interview questions and real-world applications.
Week 7: Dynamic Programming Techniques
Expand on DP strategies like coordinate DP, single and double sequence DP.
Day 31: Memorization
Focus on identifying overlapping subproblems and applying memorization for optimization.
Day 32: Practice Session
Solve memorization-based problems and review interview tips.
Day 33: DP Introduction and Coordinate DP
Learn how to approach DP problems that involve coordinate transformation techniques.
Day 34: DP with Single Sequence
Dive into single-sequence DP problems and understand the transition function.
Day 35: DP with Double Sequence
Solve problems with double-sequence DP, such as Longest Common Subsequence (LCS).
Week 8: Dynamic Programming Techniques II
Advanced DP strategies like interval and backpack problems, and game theory.
Day 36: DP with Interval
Learn how to solve interval DP problems and define transition functions.
Day 37: DP with Backpack
Explore backpack problems and optimize solutions using rolling arrays.
Day 38: DP with Game Theory
Solve game theory problems using DP, including optimal strategies for two-player games.
Day 39: Practice Session
Review common DP problem categories, including interval, backpack, and game theory.
Day 40: Practice Session
Continue practicing advanced DP problems from various categories.
Week 9: Optimization and Advanced Techniques
Cover advanced algorithms like prefix sum and monotonic stack, and refine binary search strategies.
Day 42: Prefix Sum
Learn the prefix sum technique and apply it to solve various range query problems.
Day 43: Monotonic Stack
Understand the monotonic stack and how it is used in problems like trapping rainwater.
Day 44: Binary Search II
Master advanced binary search techniques for optimization problems on ranges and results.
Day 45: Two Pointer with Partition
Learn quickselect applications and use the two-pointer technique for partition-based problems.
Week 10: Union Find, Trie, and Segment Tree
Explore advanced data structures and their applications in complex problem-solving.
Day 46: Union Find
Learn the union-find (disjoint-set) data structure and its applications in dynamic connectivity problems.
Day 47: Trie
Dive into the trie data structure and explore its use cases for string manipulation.
Day 48: Segment Tree
Understand and implement segment trees for solving range query problems efficiently.
Day 49: Practice Session
Apply union-find, trie, and segment tree to high-frequency problems.
Day 50: Practice Session
Continue practicing with advanced problems related to these complex data structures.
Week 11: Object-Oriented Programming (OOP) Design Patterns
Learn design patterns and their practical applications in software development.
Day 51: OOP Introduction
Learn about design strategies and patterns with a simple duck simulation.
Day 52: Enum, Generics & Exceptions
Study the Factory Method Pattern and its applications using design strategies.
Day 53: Factory & Abstract Factory Pattern
Implement the Factory and Abstract Factory design patterns using a pizza store example.
Day 54: Practice Session - Kindle & Vending Machine
Apply the Factory and Abstract Factory patterns in a project setting (e.g., Kindle or Vending Machine).
Day 55: Decorator Design Pattern
Learn the Decorator Pattern using a coffee maker example.
Week 12: Advanced Design Patterns
Understand and apply advanced design patterns like Singleton, Iterator, and Composite.
Day 56: Practice Session - Car Rental
Apply the Decorator design pattern in a car rental system.
Day 57: Singleton Design Pattern
Learn and implement the Singleton Pattern with a parking lot example.
Day 58: Iterator & Composite Design Pattern
Explore Iterator and Composite design patterns with a restaurant menu example.
Day 59: Practice Session - ATM
Implement the Composite and Builder design patterns in an ATM simulation.
Day 60: Observer Design Pattern
Master the Observer Design Pattern with a weather station example.
Week 13: Real-World Design Problems
Work on complex real-world projects, applying all learned design patterns.
Day 61: Practice Session - Restaurant Management
Build a restaurant management system using multiple design patterns like Command and Observer.
Day 62: Practice Session - Hotel Management
Use Singleton, Strategy, and Factory design patterns to solve hotel management problems.
Day 63: State Design Pattern
Learn and apply the State Design Pattern with a vending machine example.
Day 64: Blackjack & Chess Game
Implement State, Command, Iterator, and Observer patterns in a game simulation.
Day 65: Practice Session - Jigsaw Puzzle
Apply the Singleton pattern to solve a jigsaw puzzle problem.
Week 14: Concurrency in Object-Oriented Design
Learn about concurrency and build multi-threaded systems.
Day 66: Concurrency I
Learn about threads and locks, and implement basic multi-threading techniques.
Day 67: Concurrency II
Dive into CompletableFuture and Executor Service for better concurrency control.
Day 68: Elevator System
Design and implement an elevator system using concurrency techniques.
Day 69: Practice Session - Activity Manager & Airline Traffic Hands-on practice applying concurrency concepts in system design.
Day 70: Practice Session - Duck Simulation 2
Implement MVC and KISS principles in a second iteration of the duck simulation.
