LeetCode #34: Binary Search for Target Value in Sorted Array

Day 4 of #100DaysOfCode: Array Logic & The Magic of Truthy/Falsy in JS ⚡ Today was about mastering the fundamentals that make JavaScript unique. I split my time between solving algorithmic problems and digging deep into JS engine mechanics. 1️⃣ Data Structures & Algorithms: I tackled the "Concatenation of Array" problem (LeetCode 1929). The goal was to create an array of length 2n by concatenating two nums arrays. Key takeaway: It’s a great exercise in understanding array indexing and memory allocation. It’s simple on the surface, but efficient array manipulation is core to everything. 2️⃣ Web Development Concepts: I dove into Truthy & Falsy values. Coming from other languages, JS handling of conditionals is fascinating. I learned that 0, "", null, undefined, and NaN are the only falsy values. Everything else—including empty arrays [] and objects {}—is truthy. #JavaScript #DSA #WebDevelopment #MERNStack #CodingJourney #100DaysOfChallenge

Day 14 | From Precision to Performance (JavaScript) Solved LeetCode 3454 – Separate Squares II. This problem is a step beyond correctness — it’s about scaling mathematical reasoning efficiently. While Separate Squares I focuses on finding a balance point, Part II raises the bar by demanding: Higher performance Tighter numerical stability Careful handling of overlapping geometry at scale 💡What changes at this level: Area calculations must be optimized, not recomputed blindly Binary search must converge faster and more reliably Floating-point precision becomes a first-class concern This is where algorithmic thinking meets engineering discipline. ⏱️Complexity Mindset The challenge isn’t finding the approach it’s ensuring the approach holds under strict constraints. That’s the difference between: “It works” and “It scales.” 🎯 Takeaway Advanced problems aren’t harder because they’re trickier — they’re harder because they demand better judgment. Knowing when math, when binary search, and when optimization matter is what separates practice from real engineering. #Day14 #JavaScript #BinarySearch #ComputationalGeometry #AdvancedDSA #ProblemSolving #SoftwareEngineering #InterviewPreparation

From Sorted Data to Balanced Trees: Divide, Conquer, Balance 🌳 Solved LeetCode 108 - Convert Sorted Array to Binary Search Tree today. The solution clicked by treating the array like a search space: -Pick the middle element as the root -Recursively build the left half and right half -Stop when the range becomes invalid This guarantees a height-balanced BST without extra work. Key takeaway: Balanced trees are a natural outcome of divide-and-conquer. Choosing the midpoint at every step keeps depth under control. Strengthening recursive thinking and tree intuition. #LeetCode #DSA #BinarySearchTree #Recursion #DivideAndConquer #JavaScript #ProblemSolving #LearnInPublic

Understanding Linear Search in JavaScript Linear Search is one of the simplest algorithms, yet it’s a great starting point for building strong problem-solving skills. The idea is straightforward: 👉 Traverse the array 👉 Compare each element with the target 👉 Return the index if found, otherwise -1 Even though it’s not the most efficient search algorithm, Linear Search helps beginners understand iteration, comparisons, and time complexity—fundamental concepts in algorithms. 📌 I’m sharing more JavaScript algorithm and pattern exercises here: 👉 https://lnkd.in/ej4fNeZs Consistency beats talent. One algorithm at a time. 💪 #JavaScript #Algorithms #DataStructures #CodingPractice #WebDevelopment #LearningInPublic #100DaysOfCode

Hii Folks 🙂 Yesterday, while discussing the JavaScript Event Loop with a senior, I realized something important. Most of us explain the Event Loop using queues and the call stack. That explanation is correct, but it’s incomplete. It answers how things run, not why they behave the way they do. The deeper question came up: Before the Event Loop even starts scheduling tasks, how does JavaScript know what those tasks are allowed to access? That’s where concepts like the compiler and lexical scope quietly enter the picture. JavaScript first reads the code and builds an understanding of it. Variable scope, function boundaries, and memory references are decided before execution begins. This is not the Event Loop’s responsibility. The Event Loop only works with what already exists. Lexical scope determines which variables belong to which functions. Closures decide what stays in memory even after a function finishes. None of this is created by the Event Loop, but all of it affects how async code behaves later. Data structures play a similar hidden role. The call stack is just a stack. Task queues are just queues. The scope chain behaves like a linked structure. The Event Loop doesn’t interpret logic. It simply moves execution between these structures based on a few strict rules. That discussion made one thing clear to me: If we don’t understand compiler behavior, lexical scoping, and basic data structures, the Event Loop will always feel confusing or “magical”. Async issues are rarely caused by the Event Loop itself. They usually come from misunderstanding scope, memory, or execution order. Once you see the Event Loop as a coordinator rather than a decision-maker, a lot of confusion disappears. #JavaScript #EventLoop #LexicalScope #Closures #AsyncProgramming #WebDevelopment #FrontendDevelopment #BackendDevelopment #FullStackDeveloper #SoftwareEngineering #ComputerScience #ProgrammingConcepts #DataStructures #DeveloperLearning #LearningInPublic #TechDiscussions #DeveloperCommunity #CodingLife #Debugging #EngineeringMindset #TechCareers

✅ Solved LeetCode: Binary Tree Postorder Traversal (145) Implemented a recursive Postorder Traversal in JavaScript, following the sequence: Left → Right → Root. The solution uses a helper function traversal(curr) that: - First explores the left subtree, - Then explores the right subtree, - And finally processes the current node by pushing its value to the result array. This traversal is especially useful in scenarios like deleting a tree, evaluating expression trees, or bottom-up processing of nodes. ⏱ Time Complexity: O(n) — every node is visited once 🧠 Space Complexity: O(h) — recursion stack, where h is the height of the tree A key traversal technique every DSA learner should master! 🌳🚀

LeetCode: Longest Consecutive Sequence ✅ This problem real challenge is beating the naïve sorting approach. Strategy: Instead of sorting, I used a HashSet for constant-time lookups. The key idea is to only start counting a sequence when the current number does not have a predecessor (num - 1). From there, expand forward to count the full streak. This ensures every number is visited only once. 🕒 Time Complexity: O(n) — each element is processed at most once 📦Space Complexity: O(n) — extra space for the set 👉 The right data structure often matters more than clever loops. #LeetCode #DSA #JavaScript #ProblemSolving #LearnInPublic #CodingJourney #CSwithDev

One thing that keeps surprising me in JavaScript is how often bugs come from mental models, not syntax. A few examples I ran into recently: setTimeout with closures async + looping traps shallow vs deep copies mutation hiding in helper functions Once you slow down and ask: “What does the runtime actually do here?” a lot of things make more sense. Tools change fast. Mental models last longer. Currently strengthening: event loop behavior async flow data structures & immutability Happy to share resources if anyone else is on this path. #JavaScript #WebDevelopment #LearningInPublic #FrontendEngineering #CareerGrowth

🎯 LeetCode Win: Search a 2D Matrix (Binary Search) Just solved LeetCode 74 – Search a 2D Matrix ✅ 📌 Problem insight: The matrix looks 2D, but because • each row is sorted • the first element of every row is greater than the last element of the previous row 👉 the entire matrix behaves like one sorted array. 🧠 Key learning: Instead of doing row-by-row search, we can apply binary search on the whole matrix and achieve O(log(m × n)) time complexity. 🔑 Core trick that made it click: Mapping a 1D index to 2D coordinates row = mid / numberOfColumns col = mid % numberOfColumns This simple idea turns a complex-looking matrix problem into a clean binary search problem. 💡 What this problem reinforced for me: ✔ Always analyze given constraints carefully ✔ Matrix properties often hide powerful optimizations ✔ Binary search is not just for arrays ✔ Understanding > memorizing solutions 📈 Small wins like these build strong foundations in DSA and problem-solving. Onward to more challenges 🚀 Consistency over motivation 💪 #LeetCode #DSA #BinarySearch #MatrixProblems #JavaScript #ProblemSolving #CodingPractice #LearningEveryday

✅ Solved LeetCode: Binary Tree Inorder Traversal (94) Implemented a recursive Inorder Traversal in JavaScript, following the sequence: Left → Root → Right. The solution uses a helper function traversal(curr) that: - First explores the left subtree, - Then processes the current node by pushing its value to the result array, - And finally traverses the right subtree. This approach correctly visits nodes in sorted order for a Binary Search Tree (BST) and keeps the logic simple and intuitive using recursion. ⏱ Time Complexity: O(n) — visits every node once 🧠 Space Complexity: O(h) — recursion stack, where h is the height of the tree A must-know problem for mastering tree traversals and recursion in DSA. 🌳