Week 1: Problem-Solving Fundamentals and Data Structures
Start with the basics of algorithms and data structures that are commonly tested in coding interviews.
Day 1: Orientation
Overview of the course structure and tools.
Day 2: String & Two Pointers
String manipulation, sliding window techniques, and two-pointer algorithms.
Day 3: Binary Search
Introduction to binary search algorithms, with examples of problems like search in sorted arrays.
Day 4: Collections 1 – Stream & LinkedList
Java Streams API, LinkedList operations, and functional programming basics.
Day 5: Collections 2 – Map & Set
Review map and set data structures with relevant interview questions and problem-solving.
Week 2: Advanced Data Structures and Algorithms
Dive deeper into more advanced data structures and algorithms, essential for tackling complex problems.
Day 6: Stack & Queue
Explore stack and queue data structures, with applications in algorithms like BFS, DFS, and expression evaluation.
Day 7: Heap & Sweeping Line
Learn heap operations and the sweeping line algorithm for interval-related problems.
Day 8: Tree – 1
Introduction to trees and basic tree traversal algorithms.
Day 9: Tree – 2
Deep dive into Binary Search Trees (BSTs) and tree modifications.
Day 10: Graph & BFS – 1
Introduction to graph algorithms with breadth-first search (BFS) and level-order traversal.
Week 3: Graph Algorithms, DFS, and Dynamic Programming
Focus on advanced graph algorithms, DFS techniques, and begin learning dynamic programming.
Day 11: Graph & BFS – 2
Topological sort and shortest path algorithms in simple graphs.
Day 12: DFS – 1
Learn DFS definitions and techniques, including recursion and backtracking.
Day 13: DFS – 2
Dive into medium-level DFS problems, such as subset generation and word search.
Day 14: DFS – 3
Explore graph-based DFS problems and learn when to choose between DFS and BFS.
Day 15: DP Introduction and Coordinate DP
Learn how to approach DP problems that involve coordinate transformation techniques.
Week 4: Advanced Dynamic Programming and Specialized Techniques
Conclude with advanced dynamic programming techniques and other specialized problem-solving strategies.
Day 16: DP with Single Sequence and Double Sequence
Dive into single-sequence DP problems and double-sequence DP, such as Longest Common Subsequence (LCS).
Day 17: DP with Interval
Learn how to solve interval DP problems and define transition functions.
Day 18: Trie
Dive into the trie data structure and explore its use cases for string manipulation.
Day 19: Prefix Sum
Learn the prefix sum technique and apply it to solve various range query problems.
Day 20: Monotonic Stack
Understand the monotonic stack and how it is used in problems like trapping rainwater.
Week 5: Object-Oriented Programming (OOP) and Object-Oriented Design (OOD)
Dive into OOP principles and design patterns, solving real-world problems with hands-on case studies.
Day 21: OOP Introduction
Object-oriented principles: encapsulation, inheritance, and polymorphism.
Day 22: Enum, Generics & Exceptions
Learn Java enums, generics, exception handling, and custom exceptions.
Day 23: OOD - Vending Machine
Case study: Design a Vending Machine using design patterns like Factory and Strategy.
Day 24: OOD - Coffee Maker
Case study: Design a Coffee Maker system applying design patterns, focusing on flexibility and extendability.
Day 25: OOD - Parking Lot
Case study: Design a Parking Lot system, applying Singleton and handling exceptions for full or invalid parking.
Week 6: Advanced Object-Oriented Design and Concurrency
Explore advanced OOD concepts, work on more complex case studies, and learn about concurrency in system design.
Day 26: OOD - Amazon Locker
Design an Amazon Locker system, applying OOD principles and design patterns.
Day 27: OOD - Duck Simulation 2
Hands-on practice with real-world design patterns for flexible and maintainable systems.
Day 28: Concurrency
Learn threads, synchronization, locks, and multi-threading techniques in Java.
Day 29: OOD – Elevator
Case study: Design an Elevator system, focusing on system scalability and interactions between objects.
Day 30: OOD – Elevator (Concurrency)
Improve the Elevator design to support thread safety and efficient concurrent handling.
Week 7: Databases and Web Development Basics
Master SQL, web servers, and understand the basics of web development and frameworks.
Day 31: Databases – SQL 1
SQL basics, CRUD operations, and database schema design.
Day 32: Databases – SQL 2
Query optimization, Joins, indexing, database sharding, functions, and stored procedures.
Day 33: Web Server + Servlet 1
Introduction to web servers, HTTP, and servlets.
Day 34: Spring Web Basics
Core of Spring Framework for building web applications, including Dependency Injection, IoC, and Bean Scopes.
Day 35: Spring MVC
Model-View-Controller architecture and Spring-based implementation, with DispatchServlet.
Focus on data access, error handling, and web security in Spring-based web applications.
Day 36: Data Access
DAO patterns, JPA basics, and Spring JPA Repository for persistent data access.
Day 37: Error Handling & Validation
Exception handling strategies and input validation with AOP, ControllerAdvice, and Logging.
Day 38: Web Security
Securing web applications: authentication with JWT, and authorization with RBAC and ABAC.
Day 39: Distributed System
Introduction to Distributed Systems and core microservice components.
Day 40: Service Communication and Service Registry
Introduction to service registry, service discovery, Eureka, and Kubernetes (K8s) for managing microservices communication and orchestration.
Week 9: Microservices Infrastructure, Communication, and Scaling
Focus on microservices infrastructure, communication, and scaling distributed systems.
Day 41: Microservice Infrastructure
Load balancing with Kubernetes and Eureka, centralized configuration, and API gateway.
Day 42: Async Service Communication
Multi-threading in web applications with CompletableFuture, RabbitMQ, and Kafka.
Day 43: Transaction Management
Managing distributed transactions with 2PC and Saga, introduction to CAP theorem.
Day 44: Failure Handling
Retry mechanisms, dead-letter queues, handling single points of failure, and cascading failures with Resilience4j.
Day 45: Scaling & Centralized Logging
Log aggregation with ELK stack and scaling patterns in Kubernetes.
