Mastering Sliding Window Problems with Pattern Recognition

🚀 DSA Day 47 – LeetCode Problem 300: Longest Increasing Subsequence (LIS) Today’s problem was a classic and super important one in Dynamic Programming 📈 🔍 Problem Insight: Given an array of integers, the goal is to find the length of the longest strictly increasing subsequence. 💡 Key Approaches: 1️⃣ Dynamic Programming (O(n²)) For each element, check all previous elements Build a dp[] array where dp[i] stores LIS ending at index i 2️⃣ Optimized Binary Search Approach (O(n log n)) Maintain a temporary list (tails) Use binary search to replace elements and keep the list sorted Length of this list = LIS length ⚡ Why optimization works? We don’t need the actual subsequence — just the length. So we maintain the smallest possible tail for increasing subsequences of each length. 🧠 What I Learned: Difference between brute DP and optimized approach Using binary search in unexpected ways Importance of LIS in many advanced problems 💻 Time Complexity: DP: O(n²) Optimized: O(n log n) 📦 Space Complexity: O(n) Slowly building strong fundamentals 💪 — consistency > intensity! #DSA #LeetCode #DynamicProgramming #BinarySearch #CodingJourney #100DaysOfCode #TechGrowth

Day 81 - LeetCode Journey 🚀 Solved LeetCode 2: Add Two Numbers (Medium) — a classic linked list problem that beautifully combines arithmetic with pointer manipulation. At first, it looks like simple addition. But the twist is that numbers are stored in reverse order as linked lists, and we must simulate digit-by-digit addition. 💡 Core Idea (Simulation + Carry Handling): Traverse both linked lists simultaneously Add corresponding digits along with carry Create a new node for each digit of the result Move forward until both lists and carry are exhausted A dummy node helps in building the result list smoothly. 🤯 Why it works? Because we mimic the exact process of manual addition, handling carry at each step, ensuring correctness even when lengths differ. ⚡ Key Learning Points: • Converting real-world logic into code (digit addition) • Handling carry efficiently • Traversing two linked lists together • Using dummy node for clean construction • Managing different list lengths gracefully • Achieving O(max(n, m)) time and O(1) extra space This problem strengthens both logical thinking and linked list handling. Also, this pattern connects with: Add Binary Multiply Strings Linked List arithmetic problems Big integer calculations ✅ Better understanding of simulation problems ✅ Stronger pointer + arithmetic combination ✅ Improved handling of edge cases (carry, unequal lengths) From simple addition to linked list manipulation — this is where logic meets implementation 🚀 #LeetCode #DSA #Java #LinkedList #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

Day 29 of My DSA Journey Today I solved LeetCode 151 – Reverse Words in a String on LeetCode. 📌 Problem Given a string s, reverse the order of words. A word is defined as a sequence of non-space characters. The output string should not contain leading, trailing, or multiple spaces. Example: Input: " hello world " Output: "world hello" 🧠 Approach – String Manipulation Steps I followed: • First, remove leading and trailing spaces using trim(). • Split the string into words using split(" "). • Traverse the array from end to start. • Skip empty strings (caused by multiple spaces). • Append words into a StringBuffer with proper spacing. This approach ensures that: ✔ Words are reversed ✔ Extra spaces are removed ✔ Output is clean and formatted ⏱ Time Complexity: O(n) — Traversing the string and array 📦 Space Complexity: O(n) — Storing split words and result 💡 Key Learnings ✔ Handling string edge cases (extra spaces) ✔ Efficient use of built-in string methods ✔ Practicing string traversal and reconstruction Small problems like this help build strong fundamentals in string manipulation 🚀 Consistency continues — one day at a time 💪 #100DaysOfCode #DSA #Strings #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering

Recently solved LeetCode 225: Implement Stack using Queues, focusing on understanding how to simulate LIFO behavior using FIFO operations. Instead of using two queues, I implemented an optimized single queue approach where: On every push(x), the new element is added to the queue Then the queue is rotated so that the new element moves to the front This ensures that pop() and top() operate in O(1) Key Insight: By reordering elements during insertion, we shift the complexity to push() (O(n)) and keep retrieval operations efficient. Core Logic: Push → Insert + Rotate queue Pop → Remove front Top → Peek front This problem reinforced an important concept: Data structure behavior can be engineered by controlling operation order, not just structure choice. Always interesting to see how constraints (only queue operations allowed) lead to creative design patterns. #leetcode #datastructures #algorithms #coding #softwareengineering #programming #javascript #problemSolving #techlearning #computerscience

🚀 Day 142 — LeetCode 150 Days Challenge 🔥 Problem: Distinct Subsequences Today’s problem focused on Dynamic Programming + Recursion (Take / Not Take pattern) — a classic and very important concept for interviews. 🧠 Problem Summary Given two strings s and t, find the number of distinct subsequences of s which equals t. 👉 A subsequence is formed by deleting characters without changing the order. Example: s = "rabbbit" t = "rabbit" ✅ Output = 3 Because there are 3 different ways to delete one 'b' from s to form t. 💡 Intuition At every character of string s, we have two choices: 1️⃣ Take the character If s[i] == t[j], we match both characters and move forward. 2️⃣ Not Take the character Skip the current character of s (as we want all characters of t we only move index on s but not on t). This naturally forms a recursive decision tree. ⚡ Base Cases ✅ If we formed string t completely → return 1 ✅ If string s finishes before forming t → return 0 🧩 DP Optimization (Memoization) Since many states repeat, we store results in a DP table: dp[i][j] → number of ways to form t[j....] from s[i...] This reduces exponential recursion to: ⏱ Time Complexity: O(N × M) 📦 Space Complexity: O(N × M) 🎯 Key Learning ✔ Recognizing Take / Not Take DP pattern ✔ Converting recursion → memoization ✔ Counting problems using Dynamic Programming Dynamic Programming becomes easier once you start identifying patterns! ✅ Day 142 Complete Consistency > Motivation 💪 #LeetCode #150DaysChallenge #Day142 #DSA #DynamicProgramming #CodingJourney #ProblemSolving #SoftwareEngineer #LearningInPublic

🔥 Day 98 of #100DaysOfCode Today’s problem was all about string manipulation and greedy thinking — solving the Alternating Characters challenge. 💡 Problem Summary: Given a string of only A and B, the goal is to make sure no two adjacent characters are the same by deleting the minimum number of characters. 🧠 Approach: Instead of trying all possibilities, I used a simple and efficient strategy: Traverse the string once Compare each character with the previous one If they are the same → increment deletion count ⚡ Key Insight: Every pair of matching adjacent characters contributes exactly 1 deletion. 📊 Complexity: Time: O(n) Space: O(1) 🧪 Example: AAABBB → 4 deletions ABABAB → 0 deletions ✨ What I Learned: Sometimes the simplest greedy approach beats complex logic. Recognizing patterns in strings is a powerful skill in problem-solving! 💻 Language Used: C #Day98 #100DaysOfCode #CodingChallenge #DataStructures #Algorithms #CProgramming #ProblemSolving #DeveloperJourney

DSA series... 🚀 Chapter 3: "Sliding Window Dynamic" LeetCode #3 (Level: Medium) Longest Substring Without Repeating Characters... 🧐 At first glance, this looks like a string problem … Especially substring problem, without any doubts move to Sliding Window (Dynamic) ... 🔥 Sliding Window (Dynamic) ... ⚡ - Just move your right pointer to expand until you hit your goal, then pull your left pointer to shrink and find the optimal size. Explanation ... ✍️ 1⃣ Get the length and check the edge condition. 2⃣ Use two pointers `left` and `right`. Keep a set/map to track characters existence. 3⃣ Move `right` pointer to add characters on the string when the character is not duplicate one. 4⃣ If duplicate found, move `left pointer` to remove characters until duplicate is gone. 5⃣ Track max length during the process. --- Difference between Sliding Window Fixed vs Dynamic Programming ... 👇 ** On Fixed, we decrement 'left' pointer only once when contition met. Use if statement. ** On Dynamic Programming, we decrement 'left' pointer untill reach the condition fully met on the current window. Use while statement. Note: But sometimes it may be differ... You can see that difference from the previous chapter and the current one ... ❗ --- Easy Trigger to Remember for this pattern usage ... 😎 👉 “Longest substring without repeating characters”, 👉 “At most / no duplicate”. --- Key Insights ... 🎯 - Don’t restart the loop when duplicate appears, - Just shrink the window smartly that saves time (O(n)). Just put on your thoughts or suggestions ... 💬 Stay tuned always ... 😎 #LeetCode #SlidingWindow #DSA #CodingInterview #Java #ProblemSolving #Algorithms #TechLearning #SoftwareEngineering

Day#17 💡Cracked LeetCode #202 – Happy Number! Ever wondered if a number can be happy? 😄 Turns out, in programming… it can! 🔍 Problem Statement: A number is called Happy if: You replace the number by the sum of the squares of its digits Repeat the process If it eventually becomes 1 → it's a Happy Number If it falls into a loop → Not Happy ❌ 🧠 Key Insight: This problem is not about math… it's about cycle detection! We keep transforming the number: 👉 If we reach 1 → Done ✅ 👉 If we revisit a number → Loop detected 🔁 Approaches: 1️⃣ Using HashSet Store visited numbers Detect loop easily Time: O(log n), Space: O(log n) 2️⃣ Floyd’s Cycle Detection (Fast & Slow Pointer) 🚀 Same concept as Linked List cycle No extra space needed Time: O(log n), Space: O(1) 💻 JavaScript Code (Floyd’s Approach): var isHappy = function(n) {      const getNext = (num) => {          let sum = 0;          while (num > 0) {              let digit = num % 10;              sum += digit * digit;              num = Math.floor(num / 10);          }          return sum;      };      let slow = n;      let fast = getNext(n);      while (fast !== 1 && slow !== fast) {          slow = getNext(slow);          fast = getNext(getNext(fast));      }      return fast === 1; }; 🔥 What I Learned: Cycle detection isn’t just for linked lists Mathematical problems often hide pattern recognition Always think: Can this loop forever? 📌 Example: 19 → 82 → 68 → 100 → 1 ✅ (Happy Number) #LeetCode #DSA #ProblemSolving #CodingInterview #JavaScript

🚀 Day 139 – LeetCode 150 Days Challenge 📌 Problem: Triangle Minimum Path Sum Today’s problem is a classic example of Dynamic Programming (Bottom-Up Approach). 🧠 Problem Understanding You are given a triangle array, and your task is to find the minimum path sum from top to bottom. 👉 At each step, you can move to: Same index (j) Next index (j+1) in the next row 💡 Key Insight Instead of trying all possible paths (which is expensive 😵), we solve it bottom-up. ✔ Start from the last row (base case) ✔ Move upwards and calculate minimum path for each cell ✔ Store results in a DP table to avoid recomputation ⚙️ Approach Copy last row into DP (this is our base case) Move from second last row → top For each cell: Take minimum of two possible moves Add current value 🔁 Transition Formula dp[i][j] = triangle[i][j] + min(dp[i+1][j], dp[i+1][j+1]) ⏱️ Complexity 🟢 Time: O(n²) 🟢 Space: O(n²) 🔥 Takeaway This problem teaches: How to convert recursion → DP Importance of solving from base case upward Space-time tradeoffs in DP Consistency is the key 🔑 Let’s keep pushing towards mastering DSA 💪 #Day139 #LeetCode #DSA #DynamicProgramming #CodingJourney #150DaysOfCode