Mastering Sliding Window Technique in DSA with Java

🚀 Day 17/100 — #100DaysOfLeetCode Consistency is turning practice into intuition 💻🔥 ✅ Problem Solved: 🔹 LeetCode 424 — Longest Repeating Character Replacement 💡 Concept Used: Sliding Window Technique 🧠 Key Learning: The goal was to find the longest substring where we can replace at most k characters to make all characters the same. Key idea: Maintain a sliding window. Track the frequency of the most repeating character inside the window. If (window size − max frequency) > k, shrink the window. Continuously update the maximum valid window length. ⚡ Big Insight: We don’t need to actually replace characters — just track how many replacements would be required. This problem strengthened my understanding of optimized sliding window patterns, which appear frequently in DSA interviews. On to Day 18 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency

🔥 DSA Challenge – Day 137/360 🚀 📌 Topic: Bit Manipulation / Math 🧩 Problem: Divide Two Integers Problem Statement: Divide two integers without using multiplication, division, and mod operator. Return the quotient truncated toward zero. 🔍 Example: Input: dividend = 10, divisor = 3 Output: 3 💡 Approach: Optimized (Bit Manipulation) 1️⃣ Step 1 – Convert both numbers to long and take absolute values to avoid overflow 2️⃣ Step 2 – Use left shift (<<) to find the largest multiple of divisor 3️⃣ Step 3 – Subtract and accumulate result, then apply correct sign ⏱ Complexity: Time: O(log N) Space: O(1) 📚 Key Learning: Using bit manipulation (left shift) can significantly optimize repeated subtraction problems and avoid time limit issues. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #137DaysOfCode #LeetCode #BitManipulation

✨ Day 41 of 90 – Pattern Mastery Journey 🧠 Pattern:Reverse Alphabet Hash Pattern 💡 Approach: ✔ Used reverse looping (n → 1) to build the pattern ✔ Printed alphabets using ASCII logic `(char)('A' + i - 1)` ✔ Printed alphabet `i` times in each row ✔ Filled remaining positions with `#` using `(n - i)` ✔ Maintained proper structure and alignment 🚀 This problem helped me understand how reversing loops can change the entire pattern structure and improve control over output formatting. #PatternMasteryJourney #Java #CodingJourney #ProblemSolving

🔥 Day 140/360 – This Trick Generates All Subsets Instantly 🚀 Most people solve this using recursion… But today I learned how to generate all subsets using Bit Manipulation👇 📌 Topic: Bit Manipulation + Array 🧩 Problem: Subsets (Power Set) 📝 Problem Statement: Given an integer array, return all possible subsets (the power set). 🔍 Example: Input: [1, 2, 3] Output: [[], [1], [2], [1,2], [3], [1,3], [2,3], [1,2,3]] 💡 Approach: Bit Masking (Optimized) ✔ Step 1 – Calculate total subsets = 2ⁿ using (1 << n) ✔ Step 2 – Loop from 0 to 2ⁿ - 1 (each number represents a subset) ✔ Step 3 – Use bits to decide whether to include an element ⚡ Key Idea: Each number (mask) represents a subset in binary form. If a bit is ON → include that element. ⏱ Complexity: Time → O(n × 2ⁿ) Space → O(n × 2ⁿ) 📚 What I Learned: Bit manipulation can replace recursion in subset generation and makes the logic easier to visualize in binary. 🚀 Why This Matters: This concept is widely used in backtracking, DP, and interview problems. #DSA #Java #Coding #ProblemSolving #InterviewPrep #LeetCode #BitManipulation #TechJourney #140DaysOfCode

🔥 DSA Challenge – Day 131/360 🚀 📌 Topic: Backtracking / Recursion 🧩 Problem: N-Queens Problem Statement: Place N queens on an N×N chessboard such that no two queens attack each other. 🔍 Example: Input: n = 4 Output: [[".Q..","...Q","Q...","..Q."], ["..Q.","Q...","...Q",".Q.."]] 💡 Approach: Optimized Backtracking (Hashing) 1️⃣ Step 1 – Try placing a queen column by column 2️⃣ Step 2 – Use arrays to check if row & diagonals are safe in O(1) 3️⃣ Step 3 – Place queen → recurse → backtrack if needed ⏱ Complexity: Time: O(N!) Space: O(N) + recursion stack 📚 Key Learning: Using hashing for rows & diagonals avoids repeated checks and makes backtracking much faster ⚡ #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #131DaysOfCode #LeetCode

DSA Series... 🚀 Chapter 3 (Sliding Window Dynamic): LeetCode#424 (Level: Medium) "Longest Repeating Character Replacement" ... --- 🔹Problem You are given a string `s` and an integer `k`. You can replace "at most `k` characters" in the string to make all characters in a substring the same. 👉 Return the "length of the longest possible substring" with repeating characters after replacement. --- 🔹Constraints * `1 <= s.length <= 10^5`. * `s` consists of only uppercase English letters. * `0 <= k <= s.length`. --- 🔹Step-by-Step Procedure ... ✍️ 1⃣ Use Sliding Window (Dynamic) with two pointers: * `left = 0`, * Iterate `right` from 0 to 'n'. 2⃣ Maintain a frequency array/map for characters. 3⃣ Track: * `maxCount` - count of most frequent character in current window. 4⃣ Check window validity: * If `(window size - maxCount) > k` * Too many replacements needed. So, move `left++` and reduce frequency 5⃣ Always update: * `maxLen = max(maxLen, window size)` 6⃣ Continue until end. --- 🔹Key Takeaway ... 🎯 - We don’t actually replace characters. - We just ensure: 👉 "Window Size - Most Frequent Character ≤ k" This guarantees we can convert the whole window into one repeating character. If u have any other possible approach/suggestions, share below ... 👇 Stay tuned with same wibe ... 🔥 #LeetCode #SlidingWindow #Algorithms #DSA #CodingInterview #Java #ProblemSolving #TechLearning #SoftwareEngineering #InterviewPrep

🔥 DSA Challenge – Day 130/360 🚀 📌 Topic: Backtracking / DFS on Grid 🧩 Problem: Word Search Problem Statement: Given a 2D grid of characters and a word, check if the word exists by moving in 4 directions (no cell reuse). 🔍 Example: Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]] word = "ABCCED" Output: true 💡 Approach: Backtracking + DFS 1️⃣ Step 1 – Start from every cell matching the first character 2️⃣ Step 2 – Explore 4 directions (up, down, left, right) recursively 3️⃣ Step 3 – Mark visited cells and backtrack after exploring ✔️ Avoid revisiting the same cell ✔️ Stop early when characters don’t match ✔️ Return true as soon as full word is found ⏱ Complexity: Time: O(N * M * 4^L) Space: O(L) (recursion stack) 📚 Key Learning: Backtracking is powerful for exploring all possible paths while avoiding invalid ones using pruning. #DSA #Java #Coding #InterviewPrep #ProblemSolving #TechJourney #130DaysOfCode #LeetCode #Backtracking

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 23/100 — #100DaysOfLeetCode Another challenging day — pushing deeper into advanced Sliding Window problems 💻🔥 ✅ Problem Solved: 🔹 LeetCode 76 — Minimum Window Substring 💡 Concepts Used: Sliding Window HashMap Frequency Counting Two Pointer Optimization 🧠 Key Learning: The goal was to find the smallest substring containing all characters of another string. Key approach: Expand the window until all required characters are included. Track character frequencies carefully. Shrink the window while maintaining validity to get the minimum length. ⚡ Big Insight: Sliding Window isn’t only about longest substrings — it can also efficiently solve minimum window optimization problems. This problem really tested attention to detail and window management logic. Consistency is turning difficult problems into enjoyable challenges 🚀 #100DaysOfLeetCode #LeetCode #DSA #SlidingWindow #Algorithms #Java #ProblemSolving #CodingJourney #LearningInPublic #Consistency