3Sum LeetCode Solution with Efficient Sorting and Two-Pointer Technique

🚀 Efficiency Wins: Why Two Pointers Beat Nested Loops 👈👉 Today’s deep dive into the Two Pointer Technique was a perfect reminder that "thinking before coding" is a developer's best skill. Here is how I optimized my approach to solving Two Sum II: 🛠️ Key Technical Takeaways Kill Redundant Flags: I initially used a while(!flag) setup. I quickly realized this was extra baggage—using while (left < right) is the cleaner, more idiomatic "guardrail" that naturally prevents infinite loops. The 1-Indexed Challenge: The problem requires a 1-indexed return. I learned to handle the logic in 0-index but adjust the final output by adding 1 to avoid off-by-one errors. The "Not Found" Safety Net: If no pair exists, returning [-1, -1] is the standard way to signal "not found." Without the left < right condition, the code could crash or loop forever if the target isn't present. ⚡ The Efficiency Edge O(n) vs O(n²): Instead of checking every possible pair (slow), we use two "bookmarks" and find the answer in a single pass. Space Efficiency: By using only two variables, the space complexity stays O(1), no matter how massive the dataset. 🏆 The Milestone Successfully solved Two Sum II using a clean, linear approach! Moving from brute-force to optimized logic feels like a massive level-up. 💻 Code Snippet: function two_pointers(input, target){ let left = 0 let right = input.length - 1 while(left < right){ const currentSum = input[left] + input[right] if(currentSum === target){ return [left + 1, right + 1] } else if(currentSum > target){ right -= 1 } else{ left += 1 } } return [-1, -1] } let input = [2, 7, 11, 15] let target = 9 console.log(two_pointers(input, target)) #DataStructures #Algorithms #LeetCode #CodingInterviews #CleanCode #JavaScript #SoftwareEngineering #ProblemSolving

Day 21: The Final Logic – Closures & The Magic of Property Access 🔒✨ Today marks the grand finale of the JavaScript deep-dive. We didn't just look at the code; we looked at the Memory and the Engine logic that governs how variables live and die. 🧠 The "Crack-It Kit" Checklist: Day 21 📑 🔹 The "Stack Overflow" Trap: Understanding why a setter that calls itself triggers a recursion loop, and the "Underscore Logic" (_variable) used to fix it. 🛡️ 🔹 Getters & Setters: Moving beyond simple data storage to "Smart Properties." Whether using Class syntax or Object.defineProperty, it's about intercepting and validating every piece of data. ⚙️ 🔹 The .length Mystery: Breaking down how arr.length actually works. It’s not just a counter—it’s an exotic property managed by the engine with a setter that can physically truncate memory. 🧪 🔹 Lexical Scoping: Mastering the "Hierarchy of Access." Understanding that where you write your code determines what your functions can see. 🏛️ 🔹 Closures (The Memory Lock): The ultimate interview topic. Learning how JS "locks" parent variables in memory to keep them alive for inner functions, even after the parent has finished executing. 🔒 The JavaScript foundation is now 100% complete. From the TCP 3-way handshake to the internal mechanics of Closures, the logic is locked in. 🏗️ #JavaScript #WebDevelopment #CrackItKit #Closures #WebEngineering #CodingJourney #SoftwareArchitecture #TechInterviews #MERNStack #WanderlustProject

⚡️ 𝗦𝗽𝗲𝗲𝗱, 𝗦𝗶𝗺𝗽𝗹𝗶𝗰𝗶𝘁𝘆, 𝗮𝗻𝗱 𝗕𝘂𝗻: 𝗔 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗦𝘁𝗼𝗿𝘆 I recently put Bun to the test on a high-throughput internal tool, and the results were eye-opening. 𝗧𝗵𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 I needed to build a web interface to: Read many YAML and structured language files from an NFS (Network File System)—which are notoriously high-latency. Parse the data into user-friendly, searchable tables. Ensure the UI stayed responsive without lagging. 𝗧𝗵𝗲 𝗢𝘃𝗲𝗿-𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗧𝗿𝗮𝗽 Initially, I followed the "standard" performance playbook: The Plan: Offload parsing to Worker Threads to avoid blocking the event loop. The Parsing: Considering a PEG (Parsing Expression Grammar) parser for "maximum" efficiency. 𝗧𝗵𝗲 𝗕𝘂𝗻 𝗥𝗲𝘃𝗲𝗹𝗮𝘁𝗶𝗼𝗻 After benchmarking with Claude, I pivoted to a much simpler architecture. Because of Bun’s highly optimized JavaScript engine and I/O handling, I skipped the complexity of Workers and PEG parsers entirely. 𝗧𝗵𝗲 𝗦𝗲𝘁𝘂𝗽:   • Runtime: Bun   • Framework: Hono   • Logic: Standard Async/Await with simple Regex-based parsing. 𝗧𝗵𝗲 𝗥𝗲𝘀𝘂𝗹𝘁𝘀 Everything runs on the main thread without blocking the Hono loop. Despite the slow NFS directory, the results load in the browser in the blink of an eye. 𝗖𝗹𝗮𝘂𝗱𝗲 𝘃𝘀. 𝗚𝗲𝗺𝗶𝗻𝗶: 𝗔 𝗖𝘂𝗿𝗶𝗼𝘂𝘀 𝗖𝗮𝘀𝗲 Interestingly, Gemini suggested the route of Worker Threads. Claude, however, implemented the simpler Async/Await flow. Was it a deeper understanding of Bun's performance profile or a lack of understanding the "prompt"? Either way, I got what I need. Key Takeaway: Front load your efforts in choosing right stack, Test , Learn the capabilities, Later it will simplify the code base a lot. #WebDev #TypeScript #Bun #Hono #Performance #SoftwareEngineering #claude #gemini

🚀 LeetCode: Build an Array With Stack Operations 👨💻 The goal is to simulate stack operations ("Push" and "Pop") to build a target array using an increasing stream of integers from 1 to n. It’s a great exercise in stream processing and state management. 🛠️ My Approach 1. Stream Simulation: I used a pointer (current) starting at 1 to represent the incoming stream of integers. 🔡 2. Greedy Matching: I iterated through the target array. For every element in the target, I compared it to my current stream value. 🧹 3. Stack Operation Logic: If the stream value didn't match the target element, I recorded a "Push" followed immediately by a "Pop", effectively skipping that number. 📍 - Once the stream value matched the target element, I recorded a "Push" and moved to the next target element. ❌ The process stops as soon as the target array is fully built, ensuring we don't perform unnecessary operations for the remaining numbers up to $n$. 📊 Efficiency Analysis ⏱️ Time Complexity: O(n), where n is the maximum value in the stream, as we potentially process every number up to n. 💾 Space Complexity: O(k), where k is the number of operations performed, to store the resulting strings. #LeetCode #JavaScript #LearnInPublic #Algorithms #WebDevelopment #ProblemSolving #SoftwareEngineering #TechCommunity

✅ Solved LeetCode: Same Tree (100) — Recursive DFS Approach Implemented a clean recursive solution in JavaScript using a structural comparison strategy. Approach: - If both nodes p and q are null, return true. - If only one of them is null, return false. - Otherwise: - Check if p.val === q.val. - Recursively compare: - p.left with q.left - p.right with q.right - Return the combined result of value equality and both subtree comparisons. This approach ensures both structure and node values are identical at every level of the tree. Time Complexity: O(n) — each node is visited once Space Complexity: O(h) — recursion stack space (where h is tree height) A straightforward and elegant recursive pattern for tree comparison problems!

Most web scrapers fail at pagination. Here's why. Early in my scraping projects, I treated pagination like a for-loop problem. Click next. Repeat. Done. Then I hit a site with cursor-based pagination. My scraper broke after page 3. The issue wasn't my code. It was my assumption. Pagination isn't one pattern. It's at least four: Offset-based: Uses page numbers or limit/offset params. Predictable. Easy to parallelize. Cursor-based: Uses encoded tokens. Must scrape sequentially. Token expires or changes. Infinite scroll: Loads via AJAX. Requires intercepting network requests or simulating scrolls. Load-more buttons: Triggers JS events. Needs interaction, not URL manipulation. Most scrapers fail because engineers don't inspect the pagination strategy first. They write the loop before understanding the logic. Now, I start every scraper by opening DevTools and watching the Network tab during pagination. I identify the request type, parameters, and response structure before writing a single line of code. This saves hours of debugging later. Pagination isn't a coding challenge. It's a reconnaissance problem. Understand the pattern. Then automate it. What's the toughest pagination type you've encountered in your scraping projects? #WebScraping #Python #Automation #DataEngineering #QA #SoftwareTesting

Solved the classic Reverse Linked List problem on LeetCode today. Approach used: Iterative pointer manipulation. Key idea: Maintain three pointers — prev, curr, and next. Algorithm flow: Store the next node (next = curr.next) Reverse the link (curr.next = prev) Move pointers forward (prev = curr, curr = next) Time Complexity: O(n) Space Complexity: O(1) It’s a simple problem conceptually, but mastering pointer manipulation is essential for understanding linked list internals and many advanced data structure problems. Consistently practicing these fundamentals strengthens problem-solving intuition and prepares you for more complex algorithmic challenges. #leetcode #datastructures #algorithms #javascript #linkedlist #problemSolving #codingPractice

🚀 Cracked the 3Sum Problem on LeetCode! Today I solved the classic 3Sum problem on LeetCode — a great test of optimization and pattern recognition. 🧠 Problem: Find all unique triplets in an array that sum to 0. ❌ Brute Force Approach: 3 nested loops Time Complexity: O(n³) Fails for large inputs (TLE) ✅ Optimized Approach (Sorting + Two Pointers): Sort the array Fix one element Use two pointers to find the remaining pair Skip duplicates smartly ⏱ Time Complexity: O(n²) 📦 Space Complexity: O(1) (excluding output) 💡 Key Learning: Sometimes the real challenge isn’t solving the problem — it’s reducing time complexity. Switching from O(n³) ➝ O(n²) makes all the difference in large-scale inputs. 🔥 What I Improved: ✔ Handling duplicates efficiently ✔ Mastering two-pointer technique ✔ Debugging Time Limit Exceeded errors ✔ Writing clean, interview-ready code Problems like 3Sum strengthen core DSA concepts that are frequently asked in technical interviews. What’s your favorite array optimization problem? 👇 #DataStructures #Algorithms #JavaScript #LeetCode #CodingInterview #ProblemSolving #100DaysOfCode

📌 #60 DailyLeetCodeDose Today's problem: 73. Set Matrix Zeroes – 🟡 Medium When a problem states that you must modify the data in-place, LeetCode has taught me a useful pattern: to boost performance and avoid extra memory, you can reuse the same mutable data structure to encode all the information you need. In this problem, instead of using additional arrays or hash sets, I use the first row and the first column of the matrix as markers – while scanning the matrix, whenever I encounter a zero, I mark its entire row and column by setting the corresponding cell in the first row or first column to zero. Since the first row and first column are also part of the original data, I store their initial state in two boolean flags. This allows me to correctly decide at the end whether they themselves should be zeroed out. As a result, the solution runs in O(m × n) time and uses O(1) extra space, fully satisfying the in-place requirement. https://lnkd.in/eRxwBy4g #DailyLeetCodeDose #LeetCode #JavaScript #Algorithms #ProblemSolving #Coding

The new Date() object is finally a thing of the past. Welcome to the era of Temporal. 🕰️ We all know the "trauma" of the native Date: zero-indexed months, quirky timezone handling, and the constant reliance on external libraries like date-fns or dayjs. In 2026, the Temporal API is the standard that finally solves these issues for good. THE EVOLUTION OF DATES: 📍 The Old way (Confusion): const date = new Date(); const nextWeek = new Date(date.getTime() + 7 * 24 * 60 * 60 * 1000); // Hard to read, easy to make mistakes with milliseconds. 📍 The Modern way (Precision): const today = Temporal.Now.plainDateISO(); const nextWeek = today.add({ days: 7 }); // Readable, semantic, and safe. WHY TEMPORAL WINS: 🔹 Immutability: All Temporal objects are immutable. You no longer have to worry about accidentally mutating a date object in your state management. 🔹 Clear API: Methods like .add(), .subtract(), and .until() are intuitive. No more manual math for durations. 🔹 Native Timezones: Handling timezones with ZonedDateTime is now native and logical. No more "offset" headaches. ⚠️ Note: While Temporal is the new standard, browser support in early 2026 is strong but not universal. For older environments, you’ll still want to keep a polyfill (like @js-temporal/polyfill) in your toolkit. Small architectural shifts like this are what define a modern, maintainable codebase. If you are still fighting with new Date(), it's time for an upgrade. Have you already purged moment.js and dayjs from your projects, or is Temporal still a novelty for you? Let’s discuss below! 👇 #JavaScript #TemporalAPI #WebDev #Programming #CleanCode #SoftwareEngineering