90 day logic +dsa plan

Thank you for choosing to follow my 90-day DSA roadmap and for your clear request for a detailed, day-by-day plan with no surface-level content. As a beginner aiming to master Data Structures and Algorithms (DSA) and logic building for coding interviews, with a commitment of 3 hours daily, 6 days a week (Monday-Saturday, Sunday rest), and a preference for learning through brute force, better, and optimal solutions, I’ll provide a comprehensive, beginner-friendly plan. This roadmap will take you from zero to interview-ready, enabling you to write DSA logic independently by Day 90. I’ll include specific theory resources (e.g., GFG articles, YouTube videos with links), practice problems (with LeetCode/GFG/HackerRank links), pseudocode examples, logic-building exercises, and my support as your AI teacher, tailored to your coding interest (from our March 21, 2025 chat). The plan aligns with your goal of consistency, thoroughness, and avoiding burnout with Sunday rest.

🔥 7-Day "Code Fluency Boost" Plan

90-Day DSA Roadmap: Day-by-Day Detailed Plan

This 90-day plan (12 weeks, 6 days/week, 3 hr/day) is structured for a beginner to master DSA and logic building. Each day includes:

Theory (1 hr): Concepts via videos (YouTube links) and articles (GFG links).
Practice (2 hr): 2 problems with brute force, better, optimal solutions, pseudocode, and links.
Logic-Building Exercise: Pseudocode, visualization (e.g., flowcharts), or verbal explanations.
Resources: Specific links to videos, articles, and problem platforms (LeetCode, GFG, HackerRank).
Schedule: Mon-Sat (3 hr/day: 1 hr theory, 2 hr practice); Sun rest.
Checkpoints: Weeks 4, 8, 12 to assess progress.
Problem Count: ~150-180 problems (10-12/week, easy to hard).
My Support: Share code/pseudocode daily; I’ll review, fix errors, and explain concepts in beginner terms.

The plan uses Python for simplicity and assumes you’ll use LeetCode, GFG, and HackerRank. Each week builds on the previous, starting with basics (Week 1) and progressing to advanced topics (Week 12). All links were verified as of August 8, 2025, for accuracy.

Week 1: Programming Basics & Logic Building

Objective: Master variables, loops, conditionals, functions, Big-O notation.

Logic Focus: Break problems into inputs, processes, outputs. Write pseudocode.

Goal: Solve 10 easy problems. Write pseudocode for each.

Platforms: HackerRank, LeetCode (Explore: Beginner).

Day 1 (Mon): Variables & Input/Output
- Theory (1 hr):
  - Video: NeetCode’s “Python for Beginners” (20 min) (YouTube).
  - Article: GFG’s “Python Variables” (20 min) (Link).
  - Note basics: variable assignment (x = 5), input (input()), output (print()).
- Learn variables (int, float, string), data types, input/output in Python.
- Practice (2 hr):
  - Problem 1: HackerRank: Simple Array Sum (Link).
    - Brute Force: Loop, add each element (O(n)).
    - Better: Single variable sum (O(n)).
    - Optimal: Built-in sum() (O(n), cleaner).
    - Pseudocode:
```
Input: array of numbers
Initialize sum = 0
For each number in array:
    Add number to sum
Return sum
```
    - Logic Exercise: Write pseudocode, then code. Draw a flowchart showing loop iteration.
  - Problem 2: HackerRank: Solve Me First (Link).
    - Brute Force: Add two numbers directly (O(1)).
    - Better/Optimal: Same, but with clear variable names (O(1)).
    - Pseudocode:
```
Input: two numbers a, b
Return a + b
```
    - Logic Exercise: Explain logic in plain English (e.g., “Take two numbers, add them”).
- Support: Share code/pseudocode; I’ll check for errors (e.g., incorrect input handling).
Day 2 (Tue): Loops
- Theory (1 hr):
  - Learn for/while loops, loop structure (start, condition, update).
  - Video: Abdul Bari’s “Loops in Programming” (15 min) (YouTube).
  - Article: GFG’s “Python Loops” (20 min) (Link).
  - Note: for loop (for i in range(n)), while loop (while condition).
- Practice (2 hr):
  - Problem 1: HackerRank: Loops (Link).
    - Brute Force: Print numbers manually (impractical).
    - Better: Use for loop (O(n)).
    - Optimal: Same, with clean output format (O(n)).
    - Pseudocode:
```
Input: number n
For i from 0 to n-1:
    Print i
```
    - Logic Exercise: Draw a flowchart for the loop (e.g., “i starts at 0, check i < n, print i, i++”).
  - Problem 2: LeetCode: Print Numbers (Link).
    - Brute Force: Manual if-else for each number (impractical).
    - Better: Loop with modulo checks (O(n)).
    - Optimal: Same, with concise conditions (O(n)).
    - Pseudocode:
```
Input: number n
For i from 1 to n:
    If i divisible by 3 and 5: Print "FizzBuzz"
    Else if divisible by 3: Print "Fizz"
    Else if divisible by 5: Print "Buzz"
    Else: Print i
```
    - Logic Exercise: List loop conditions in plain English.
- Support: Share code; I’ll fix loop errors (e.g., infinite loops).
Day 3 (Wed): Conditionals
- Theory (1 hr):
  - Learn if-else, nested conditionals, logical operators (and, or, not).
  - Video: NeetCode’s “Python Conditionals” (15 min) (YouTube).
  - Article: GFG’s “Python If-Else” (20 min) (Link).
  - Note: if condition, elif, else syntax.
- Practice (2 hr):
  - Problem 1: HackerRank: If-Else (Link).
    - Brute Force: Multiple nested ifs (O(1)).
    - Better: Single if-elif chain (O(1)).
    - Optimal: Same, with clear logic (O(1)).
    - Pseudocode:
```
Input: number n
If n odd: Print "Weird"
Else if n even and 2<=n<=5: Print "Not Weird"
Else if n even and 6<=n<=20: Print "Weird"
Else: Print "Not Weird"
```
    - Logic Exercise: Write all conditions in plain English.
  - Problem 2: LeetCode: Sign of the Product of an Array (Link).
    - Brute Force: Multiply all numbers (O(n)).
    - Better: Count negatives (O(n)).
    - Optimal: Same, with early exit on zero (O(n)).
    - Pseudocode:
```
Input: array of numbers
Initialize sign = 1
For each number:
    If number = 0: Return 0
    If number < 0: Flip sign
Return sign
```
    - Logic Exercise: Draw decision tree for conditions.
- Support: Share code; I’ll check conditional logic errors.
Day 4 (Thu): Functions
- Theory (1 hr):
  - Learn functions, parameters, return values, modularity.
  - Video: Tushar Roy’s “Functions in Python” (15 min) (YouTube).
  - Article: GFG’s “Python Functions” (20 min) (Link).
  - Note: def function_name(params), return statement.
- Practice (2 hr):
  - Problem 1: HackerRank: Factorial (Link).
    - Brute Force: Multiply manually (O(n)).
    - Better: Recursive function (O(n)).
    - Optimal: Same, with edge case (0! = 1) (O(n)).
    - Pseudocode:
    - Logic Exercise: Break function into steps (e.g., “Check base case, recurse”).
  - Problem 2: LeetCode: Power of Two (Link).
- Support: Share code; I’ll ensure proper function structure.
Day 5 (Fri): Big-O Notation
Day 6 (Sat): Recap & Mixed Practice
Day 7 (Sun): Rest. Reflect on Week 1 (e.g., “Did loops make sense?”).