Master LeetCode Sliding Window Problems with 3-Step Template

Day 27 – DSA Journey 🚀 | Strings As part of my daily DSA practice, I worked on a string manipulation problem from LeetCode that strengthened my understanding of controlled in-place operations and pattern-based traversal. 📌 Problem Practiced: Reverse String II 🔍 Core Idea: The string needs to be processed in blocks of size 2k. For every such block, only the first k characters are reversed while the remaining characters are left unchanged. This pattern is repeated until the entire string is processed. 📌 Concepts Applied: • Converting strings to character arrays for in-place modification • Iterating with fixed step sizes (2k) • Reversing a specific portion of an array • Handling edge cases using boundary checks • Writing clean and efficient loop-based logic 💡 Key Insight: Breaking the string into predictable 2k segments simplifies the problem and allows precise control over which characters need to be reversed without extra complexity. ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) Practicing problems like this is helping me become more confident with string traversal patterns and in-place transformations. #Day27 #DSAJourney #LeetCode #Strings #Java #ProblemSolving #LogicBuilding #LearningInPublic #Consistency

LeetCode POTD #3013 - Divide an Array Into Subarrays With Minimum Cost II (02 February 2026) This one looks messy at first glance, but the trick is how you frame it. The first subarray is forced to start at index 0. So the real decision is where the last subarray starts. Fix the starting index of the last subarray at i. Now the constraint i(k-1) - i1 <= dist forces the remaining k-2 subarrays to start inside the window: [i - dist, i - 1] At that point, the problem becomes clean: From a sliding window of length dist, continuously maintain the smallest k-2 values. To do this efficiently: -> Use two ordered sets -> One keeps the k-2 smallest elements -> The other holds the rest -> Maintain the sum while the window slides Total cost for each i: nums[0] + nums[i] + sum_of_k-2_smallest Minimum across all valid i is the answer. Key takeaway: Hard problems usually aren’t about complex code -> they’re about choosing the right perspective. Time Complexity -> O(n log n) Space Complexity -> O(n) #LeetCode #POTD #HardProblems #DataStructures #SlidingWindow #Java #ProblemSolving

🚀 Solved LeetCode 643 – Maximum Average Subarray I Today I worked on strengthening my understanding of the Sliding Window pattern. At first, it looked like a simple subarray problem. But the real challenge was solving it efficiently. The key was: • Use a fixed-size sliding window • Avoid recalculating the full sum every time • Reuse the previous window’s computation • Track the maximum sum carefully This helped me understand: ✔ How fixed sliding window works internally ✔ Why initialization of the first window matters ✔ How optimization improves time complexity to O(n) ✔ Importance of recognizing common DSA patterns Small optimizations make a big difference in performance. Step by step improving problem-solving skills. 💻 #LeetCode #Java #ProblemSolving #DataStructures #CodingJourney

Today’s focus shifted toward character-level manipulation using StringBuilder. Instead of only using built-in methods, the goal was to understand how characters can be read, transformed, and written back using logic. What became clearer during practice: - Every character has an ASCII value, which allows manual case conversion - StringBuilder makes it possible to update characters directly without creating new strings - Loop-based transformations help in building real problem-solving thinking, not just method usage One small transformation example: StringBuilder sb = new StringBuilder("PraTiM007"); for (int i = 0; i < sb.length(); i++) { char ch = sb.charAt(i); if (ch >= 'A' && ch <= 'Z') ch = (char)(ch + 32); // convert to lowercase else if (ch >= 'a' && ch <= 'z') ch = (char)(ch - 32); // convert to uppercase sb.setCharAt(i, ch); } System.out.println(sb); Output : pRAtIm007 The biggest realization here: - Real learning starts when logic replaces built-in shortcuts - Small character problems quietly build strong algorithmic thinking Not perfect yet, but the control over strings now feels much more real than before. #java #stringbuilder #problemSolving #codingjourney #learninginpublic #softwaredevelopment

𝗗𝗮𝘆 𝟯𝟵/𝟭𝟬𝟬 | 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗟𝗶𝗻𝗸𝗲𝗱 𝗟𝗶𝘀𝘁 𝗜𝗜 Day 39 ✅ — Reverse with precision. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 #𝟵𝟮: Reverse Linked List II (Medium) 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: Reverse a linked list between positions left and right. Not the entire list—just a specific portion. Day 31: Reversed entire list. Day 39: Reverse only a section, in one pass. The trick? Dummy node + careful pointer manipulation. Navigate to position left-1, then reverse nodes in-place by repeatedly moving the next node to the front. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 👉 Use dummy node to handle edge cases 👉 Navigate to node before left position 👉 Reverse nodes from left to right using pointer manipulation 👉 Reconnect the reversed section Time: O(n), Space: O(1) 𝗠𝘆 𝗥𝗲𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Ten linked list problems. This one built directly on Day 31's reversal logic but added precision control. The dummy node pattern keeps proving its value—simplifies edge cases every time. 𝗖𝗼𝗱𝗲:🔗 https://lnkd.in/gpYMzgJT 𝗗𝗮𝘆 𝟯𝟵/𝟭𝟬𝟬 ✅ | 𝟲𝟭 𝗺𝗼𝗿𝗲 𝘁𝗼 𝗴𝗼! #100DaysOfCode #LeetCode #LinkedList #PointerManipulation #DataStructures #CodingInterview #SoftwareEngineer #Java #Algorithms #MediumLevel #Programming #InPlaceAlgorithm

Today’s Problem of the Day was Trapping Rain Water — a classic but tricky problem that tests your understanding of two-pointer optimization. ✅ 1111 / 1111 test cases passed ✅ 1 / 1 attempt 🔥 4-day streak ⭐ 8/8 points Instead of using extra prefix/suffix arrays, I implemented the optimized O(n) time and O(1) space two-pointer approach. Key idea: At every index, trapped water depends on min(leftMax, rightMax) - height[i] The challenge isn’t writing code — it’s recognizing why the smaller boundary determines the water level. Problems like this reinforce: • Boundary thinking • Space optimization • Clean pointer movement logic Consistency > Motivation. On to Day 5. 💪 #GeeksforGeeks #ProblemOfTheDay #DataStructures #Algorithms #Java #CodingJourney #100DaysOfCode

Day 47: Flipping bits and taking names! 🔄 Problem 190: Reverse Bits Today's challenge was to reverse the bits of a 32-bit unsigned integer. While there are elite bit-manipulation tricks for this, I decided to trust my own logic first. The Game Plan: 1. Convert the integer to a binary string. 2. Reverse the string using StringBuilder. 3. Manually pad the trailing zeros to ensure it stays a full 32-bit representation. 4. Parse it back to an integer. Is it the most optimal O(1) bitwise solution? Not yet. But implementing your own logic before peaking at the "perfect" solution is how you actually learn. I'm hitting the books now to master the bit-shift approach for the next round. 🧗♂️ #LeetCode #Java #BitManipulation #Algorithms #CodingChallenge #ProblemSolving

📐 Day 66/100: Valid Triangle Number - Two Pointers on Sorted Day 66. Count valid triangles. Sort first, then two pointers. Clean. ✅ 📌 Problem: Count how many triplets can form valid triangles. Triangle rule: a + b > c (sum of two sides > third side) 💡 Solution: 1. Sort array 2. Fix largest side (k) 3. Two pointers for other two sides 4. If nums[i] + nums[j] > nums[k]: → All pairs from i to j work! → count += (j - i) 🎯 The Trick: After sorting, if nums[i] + nums[j] > nums[k], then ALL elements between i and j also satisfy this with j. Example: [2,3,4,5], k=3 (value 5) i=0 (2), j=2 (4): 2+4>5? Yes count += (2-0) = 2 triangles: (2,4,5) and (3,4,5) 📊 Complexity: O(n²) time, O(1) space Day 66. Geometry + algorithms. 📐 #100DaysOfCode #DSA #LeetCode #Day66 #Java #TriangleNumber #TwoPointers #Sorting

𝗗𝗮𝘆 𝟱𝟰/𝟭𝟬𝟬 | 𝗦𝘄𝗮𝗽 𝗡𝗼𝗱𝗲𝘀 𝗶𝗻 𝗣𝗮𝗶𝗿𝘀 Day 54 ✅ — Pointer choreography. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅LeetCode 𝗣𝗿𝗼𝗯𝗹𝗲𝗺 #𝟮𝟰: Swap Nodes in Pairs (Medium) 𝗪𝗵𝗮𝘁 𝗖𝗹𝗶𝗰𝗸𝗲𝗱: Swap every two adjacent nodes. Not their values—the actual nodes themselves. This is pure pointer manipulation. Three pointers (prev, first, second), six pointer adjustments per swap. Get one wrong and the list breaks. But when you visualize it? It's just a careful dance of reconnections. 𝗠𝘆 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵: 👉 Dummy node for clean head handling 👉 Track prev, first, and second nodes 👉 Reconnect: first.next = second.next 👉 Reconnect: second.next = first 👉 Reconnect: prev.next = second 👉 Move to next pair Time: O(n), Space: O(1) 𝗠𝘆 𝗥𝗲𝗮𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Twenty-five linked list problems. Yesterday swapped values. Today swapped the nodes themselves. The difference? Values = easy. Nodes = pointer precision. This is what 25 days of practice builds—the ability to rewire a data structure without breaking it. 𝗖𝗼𝗱𝗲:🔗 https://lnkd.in/gfn4EgTr 𝗗𝗮𝘆 𝟱𝟰/𝟭𝟬𝟬 ✅ | 𝟰𝟲 𝗺𝗼𝗿𝗲 𝘁𝗼 𝗴𝗼! #100DaysOfCode #LeetCode #LinkedList #PointerManipulation #DataStructures #CodingInterview #SoftwareEngineer #Java #Algorithms #Programming #MediumLevel #PrecisionCoding

Day 16 – LeetCode 1004 | Sliding Window Done Right (O(n) Solution) Day 16 of solving problems consistently. Solved LeetCode 1004 – Max Consecutive Ones III. Problem: Given a binary array, you can flip at most k zeros. Return the maximum number of consecutive 1s possible. Brute force checks every subarray → O(n²) → wasteful. A better approach is Sliding Window + Two Pointers → O(n). Core logic: • Expand window with right pointer • Count zeros • If zeros exceed k → move left pointer • Track max window length This problem is a good reminder that: Constraints usually hint the optimal technique. If you see “subarray + max/min + linear time” → think Sliding Window first. Consistency builds skill. 16 days. No breaks. Code + explanation in the video 👇 #LeetCode #DSA #Algorithms #SlidingWindow #TwoPointers #Java #ProblemSolving #CodingInterview #SoftwareDeveloper #100DaysOfCode #TechJourney