Mastering Sliding Window Approach for Efficient Code

Day 17 of #LeetCodeDaily Problem: Sort Colors (Medium) Given an array with values 0, 1, 2 representing colors (Red, White, Blue), sort them in-place without using any built-in sort. 🔍 My Approach: Use Dutch National Flag Algorithm (3-pointer approach) Maintain three pointers: low → position for 0 mid → current element high → position for 2 Algorithm: If element is 0 → swap with low, move both low & mid If element is 1 → just move mid If element is 2 → swap with high, move high only This ensures: Left side → all 0s Middle → all 1s Right side → all 2s ⏱ Time: O(n) 📦 Space: O(1) Single pass + in-place sorting makes it optimal 🚀 💡 Learning: When array has limited values → think partitioning Key insight → don’t move mid when swapping with high Always re-check swapped elements Classic problem to test pointer manipulation skills #ProblemSolving #LeetCode #JavaScript #DSA #Algorithms #Array #InterviewPrep #CodingJourney #30DaysDSAChallenge #LearningInPublic

Stop declaring variables until you read this! 🛑 Most developers think they know variables. But using var when you should be using const is the fastest way to create "ghost bugs" in your code. I’ve put together a full guide on the 4 ways to declare variables in 2026. Inside this carousel: ✅ The "Hidden" Automatic declaration (and why it’s dangerous). ✅ The breakdown of Scope: Function-scoped vs. Block-scoped. ✅ Why const isn't actually 100% immutable. ✅ When to use let vs. var. Why you need this: Mastering variables isn't just about syntax; it’s about memory management and preventing global variable leaks that slow down your applications. The Benefit: Clean code = Less debugging. Understanding these fundamentals will make your logic more predictable and your PRs much smoother. Tell me in the comments: Are you still using var in 2026, or is it const all the way for you? 🛡️ #JavaScript #WebDevelopment #CodingTips #FrontendEngineer #JSVariables #CleanCode

Continuing the 10-week series where I share questions that separate familiarity from real understanding. 🔹 Engineering Depth – Week 5: Prototype Chain Q: How does JavaScript actually resolve a property when it’s not found on an object? “It doesn’t stop at the object.” “It walks the prototype chain.” “It stops only at null.” Example: const user = {  name: "Shabana" }; console.log(user.toString()); toString() is not defined on user. So JavaScript looks up: user → user.__proto__ → Object.prototype → null This lookup is called the prototype chain. Why this matters in real systems: • Hidden performance costs in deep chains  • Unexpected overrides of built-in methods  • Bugs from shared prototype mutations Understanding this helps you: – Debug strange object behavior  – Avoid modifying global prototypes  – Design cleaner inheritance patterns Objects don’t just hold properties. They delegate them. #JavaScript #Prototype #SoftwareEngineering #FrontendDevelopment #BackendDevelopment #TechDepth

🧩 DSA Problem: Alternate Elements of an Array Here’s a simple yet important problem to test your fundamentals 👇 👉 Question: Given an array, print every alternate element starting from the first index (0, 2, 4, ...) 🧪 Example Input: [10, 20, 30, 40, 50] Output: 10 30 50 💡 This problem helps you understand: ✔ Array traversal ✔ Index-based logic ✔ Space vs in-place optimization 🚀 I’ve explained multiple approaches (optimized + beginner-friendly) in detail here: https://lnkd.in/geXA-etA https://lnkd.in/gSPwE85b 💬 How would you solve this — in-place or using a new array? #JavaScript #DSA #CodingInterview #WebDevelopment #100DaysOfCode

This one change removed 80% of our Redux Code Most developers have a love-hate relationship with Redux. The "love" is for the predictable state; the "hate" is for the mountain of boilerplate. In our project, as we grew, we hit a wall. For every new API call, we were manually writing: - 5 Action Types - 3 Action Creators - A customized Reducer - A complex Saga watcher/worker It was repetitive and error-prone. So, we decided to automate the boredom away. We built a Redux Module Factory that handles the entire lifecycle (Types, Actions, Reducer, and Sagas) with a single configuration call. The Results:  - 100+ APIs currently running on this automated architecture in production. - 80% reduction in boilerplate code. - "Zero-touch" Registration: Our system automatically aggregates and injects new modules into the Root Reducer and Root Saga. - Consistency: Every API call now follows the exact same state pattern (loading, data, error). Engineering isn't just about finishing tasks—it’s about building systems that make those tasks easier for everyone. #Javascript #React #Redux #SoftwareEngineering #Automation #SystemDesign #DeveloperExperience

📣 𝗡𝗲𝘅𝘁 𝗕𝗹𝗼𝗴 𝗶𝘀 𝗛𝗲𝗿𝗲! ⤵️ Array Methods You Must Know — Writing Less Loops, More Logic ⚡🧠 Working with arrays using only loops feels repetitive. Modern JavaScript gives cleaner tools — and this blog explains them step by step. 🔗 𝗥𝗲𝗮𝗱 𝗵𝗲𝗿𝗲: https://lnkd.in/gqQKdsAc 𝗧𝗼𝗽𝗶𝗰𝘀 𝗰𝗼𝘃𝗲𝗿𝗲𝗱 ✍🏻: ⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺⎺ ⇢ Adding and removing elements using push, pop, shift, unshift ⇢ Looping arrays cleanly with forEach() ⇢ Transforming data using map() ⇢ Filtering values using filter() ⇢ Combining array values using reduce() ⇢ Traditional loops vs modern method chaining ⇢ Real beginner examples and practice assignments ⇢ Common mistakes like forgetting return in map/filter ⇢ Mental model to choose the right method 💬 If arrays still feel like “write loop → do work → repeat”, this article helps you understand how modern array methods make code cleaner, shorter, and easier to reason about. #ChaiAurCode #JavaScript #ArrayMethods #WebDevelopment #ProgrammingBasics #Beginners #LearningInPublic #100DaysOfCoding

💡 Understanding Two Sum — It’s Not About the Numbers, It’s About Timing Today I revisited the classic Two Sum problem and realized something simple but powerful: 👉 The algorithm doesn’t try to find the best pair 👉 It doesn’t look for largest numbers 👉 It doesn’t check all possibilities It simply returns the first valid pair it encounters during traversal Key Insight: The result depends entirely on the order of iteration Example: nums = [1, 2, 4, 5, 6, 8] target = 10 We might expect: 2 + 8 = 10 → indices [1, 5] But the algorithm returns: 4 + 6 = 10 → indices [2, 4] Why? Because: 4 is seen earlier 6 appears soon after The algorithm stops immediately when it finds the first match The Rule to Remember: 🧠 Hash map solution returns the first valid pair based on traversal order Takeaway: This isn’t just about solving Two Sum — it’s about understanding how algorithm behavior is shaped by execution flow, not just logic. Once you see this, you stop memorizing solutions and start actually understanding them. #JavaScript #Algorithms #CodingInterview #SoftwareEngineering #ProblemSolving

Found something in Claude Code today that I'd been completely missing. There is a command called /effort that controls how hard Claude actually thinks before it responds. /effort is a reasoning depth control in Claude Code. It sets how many tokens Claude spends thinking before it responds. It affects thinking depth, tool call appetite and response length, all at once. It has four levels: → low: skips reasoning entirely; fast, cheap, good for renaming a variable; minimal tool calls (how many tools Claude uses mid-task), typos and boilerplate. → medium: default for most plans; thinks when it needs to and skips when it doesn't; fine for everyday coding. → high: real reasoning budget; good for complex debugging, multi-file refactors, and architecture decisions. → max: no token constraint on thinking; supported only by Opus 4.6 and doesn't persist across sessions unless you set this as an env variable. Trade-off: the difference between low and max on a hard problem is 10x in time and tokens. Which means most of us are either overpaying on easy tasks or underthinking hard ones without realising it. But here's the part that actually stuck with me: Max effort doesn't fix bad context. The sessions that nail complex tasks share one pattern: a structured plan before the first prompt. The effort level just determines how hard Claude works with what you give it. It's the same as any product decision, really. You don't over-engineer a minor fix or cut corners on something that ships to users. The same logic applies here. Quality costs more. But garbage in at max effort is still garbage out. So, better to use max for genuinely hard problems (system design, race conditions, deeply nested bugs), not as a blanket setting. Type /effort in Claude Code and see where yours is set. P.S: All thanks to Arvind Satyapal Menon - always teaching me crazy new things!

🪟 The Sliding Window Pattern That Reuses Work Efficiently ⚡📊 Solved LeetCode 1343 using a clean rolling sum sliding window approach. 🔍 Problem Count subarrays of size k whose average is at least threshold. 🧠 Initial thought Recalculate every window sum from scratch. Works, but wastes repeated work. 🚀 Better approach • Build the first window sum once • For every next step: ➖ remove outgoing element ➕ add incoming element • Check if average meets threshold 🧩 Mental model Adjacent windows overlap by k - 1 elements. So instead of restarting, reuse the previous sum. The core update step: sum += arr[i] - arr[i - k] 🎯 Interview takeaway Whenever windows overlap heavily, think: reuse previous computation instead of recalculating. 💡 Practical insight This exact rolling update pattern appears in many fixed-size sliding window problems like 643, 1456, and 1343. #DSA #LeetCode #Algorithms #SlidingWindow #JavaScript #CodingInterview #InterviewPrep

Solved one of the most famous Linked List problems today on LeetCode: Add Two Numbers This problem looks simple at first, but it really tests your understanding of traversal, carry handling, and clean pointer manipulation. 💡 Big Takeaway: Using a Dummy (Sentinel) Node makes the solution much cleaner and avoids edge cases while building the result list. let dummy = new ListNode(0); let current = dummy; Now instead of worrying about initializing the head separately, you can directly keep attaching nodes: current.next = new ListNode(digit); current = current.next; Core Logic: Traverse both lists simultaneously Add digits along with carry Store sum % 10 as the node value Carry forward Math.floor(sum / 10) while (l1 || l2 || carry) { let sum = (l1 ? l1.val : 0) + (l2 ? l2.val : 0) + carry; carry = Math.floor(sum / 10); } ⚡ Why this matters: Handling carry + unequal lengths + null nodes in a clean way is a pattern used in many real-world problems. Small problem, but powerful pattern #LeetCode #DSA #LinkedList #JavaScript #ProblemSolving