How Binary Search Works: A Simple Explanation

🌟 Day 4 — 21 Days Problem Solving Challenge 🌟 This post isn’t extraordinary — it’s just a small part of my learning story. Today, I faced lots of challenges, got stuck many times, and spent hours trying to solve problems. But in the end, I solved them all by myself — no AI, no Google, just pure logic and patience. The challenge was to solve everything without using any string or Math functions — only pure mathematics. Here’s what I worked on today 👇 1️⃣ Split Number into Digits Input: N = 12345 → Output: [1, 2, 3, 4, 5] 2️⃣ Remove the Decimal Point (Mathematically) Input: N = 12.34 → Output: 1234 3️⃣ Separate Whole and Fractional Parts Input: N = 5.75 → Output: Whole = 5, Fraction = 0.75 4️⃣ Count Whole and Fractional Digits Separately Input: N = 12.345 → Output: Whole Count = 2, Fraction Count = 3 5️⃣ Generate a Decimal Number from Whole and Fractional Digits Input: Whole = [1, 2], Fraction = [3, 4] → Output: 12.34 6️⃣ Check if a Number is a Palindrome Input: N = 121 → Output: Palindrome 7️⃣ Check if a Number is an Armstrong Number Input: N = 153 → Output: Armstrong Number ✨ Example: 1³ + 5³ + 3³ = 153 This series is really helping me sharpen my logical thinking and improve how I approach problems. If you’re an absolute beginner and want to take your problem-solving skills to the next level, I highly recommend checking out Anurag Singh’s free YouTube series. Every day is a new challenge, a new lesson, and a small victory. #WebDevelopment #FrontendDevelopment #WebDeveloper #JavaScript #HTML #CSS #ReactJS #React #TailwindCSS #Tailwind #Coding #Programming #100DaysOfCode #LearningJourney #ProjectTips #CodeChallenge #LearningToCode #BuildInPublic #CodingTips #CareerGrowth #Innovation #Technology #WebDesign #DevProjects #LogicBuilding #JSLogic

Day 113: Deep Dive into Core JavaScript & DSA Fundamentals! I spent today drilling into fundamental programming concepts, using multiple approaches for each problem to maximize my understanding and coding flexibility. This is the crucial prep work before jumping back into advanced Data Structures and Algorithms. 🎯 Today's Focus Areas: String Manipulation: Implemented String Reversal using four distinct methods: Built-in methods (.split(), .reverse(), .join()) Iterative for loop Recursion with substring() Recursion with slice() (and noted the difference between slice and substring on negative indices!) Mathematical Logic: Factorial Finder: Solved iteratively and recursively. Sum of Digits: Solved using string conversion, iterative while loop, and recursion. Power Calculation and Simple Interest Calculation. Conditional & Array Logic: Created a precise function to check for a Leap Year (year % 4 == 0 && year % 100 !== 0 || year % 400 == 0). Found the Biggest Number in an array without using the .sort() method, then compared it with Math.max(). Implemented robust Palindrome Checkers (for individual words and for finding all palindromic substrings). Wrote functions for Vowel/Consonant Counting, Finding Factors, and Calculating Average. Determined the Smallest of Three Numbers using conditional operators and Math.min(). It's been a great exercise in code efficiency and algorithmic thinking. Feeling much more confident and ready to accelerate into my DSA curriculum soon! #JavaScript #DSA #CodingChallenge #ProblemSolving #FullStack #Day113 #LearningInPublic

Think any value equals itself? Adorable. `NaN === NaN` is `false`. Your simple `if (result === NaN)` check for bad math will silently fail every single time. You have to use `Number.isNaN()`. Is this strict mathematical purity, or a sadistic language trap designed to make debugging a nightmare? #GaboTips #JS

Bookmate is an innovative web application designed to recommend books based on the reader’s current mood. Unlike traditional recommendation systems that rely only on past reading history, Bookmate uses mood recognition technology through webcam emotion detection or text sentiment analysis to suggest books that resonate emotionally with the user. 💡 Key Features: AI-driven mood detection using facial expressions or text input Personalized book recommendations aligned with the reader’s emotions Simple, user-friendly web interface built with HTML and Python Chatbot integration using Rasa for interactive recommendations 📚 Impact: Bookmate transforms how readers discover new books by blending technology with emotions, making reading more meaningful and personalized.

🚀 Mastering the KMP (Knuth–Morris–Pratt) Algorithm in JavaScript Today I explored one of the most efficient string matching algorithms — KMP Algorithm. It’s an optimized pattern searching method that avoids unnecessary comparisons, making it faster than the naive approach. 🧠 Key Concepts: Preprocesses the pattern using the LPS (Longest Prefix Suffix) array. Avoids re-checking characters that are already matched. Runs in O(n + m) time — perfect for large text searches. 📘 Use Case: Efficient searching in text editors, DNA sequence analysis, and search engines. 🔥 Learning takeaway: Understanding how preprocessing (LPS array) improves performance is a game-changer in algorithm design. #JavaScript #DSA #Algorithms #Coding #LearningJourney #KMPAlgorithm #Programming

Ever wondered how “Ctrl + F” finds text so fast? ⚡ That’s thanks to algorithms like Knuth–Morris–Pratt (KMP) — built to search patterns quickly and efficiently. It’s still used in real-time apps today — from chat filters and DNA searches to cybersecurity log scans. Old algorithm, modern impact. 💡

DSA JOURNEY UPDATE — Strings from Basic ➝ Medium (Leveling Up!) Today’s DSA grind was all about mastering string manipulation — starting from the basics and moving confidently into medium-level logic. Each problem pushed me to think cleaner, faster, and more algorithmically. Here's what I tackled 👇 🔹 1. Remove Spaces (Basic) A warm-up challenge! Cleaned the given string by removing all spaces — even multiple or leading ones. Perfect refresher on simple string traversal. 🔹 2. Count the Characters (Easy) Counted how many characters occur exactly N times, with consecutive occurrences treated as a single appearance. Loved the twist — makes you think beyond simple frequency tables! 🔹 3. k-Anagram (Medium) This one tested logical thinking 🔥 Two strings are k-anagrams if they can match after changing at most k characters. Learned how frequency mismatch directly relates to minimum edits. A great interview-level question! 🔹 4. Count of Strings With Constraints (Medium) Given length n, count how many strings can be formed with letters a, b, c under constraints — at most 1 b and 2 c. A pure combinatorics problem → zero loops → O(1) logic. Super satisfying to solve! 🎯 What I Gained Today ✔ Strengthened string manipulation skills ✔ Clear idea of frequency-based logic ✔ Practical exposure to combinatorics ✔ Confidence to tackle medium-level questions next If you're also grinding DSA, remember — consistency beats intensity. Let’s keep learning, leveling up, and building momentum one problem at a time! 🚀 #dsa #codingjourney #leetcode #geeksforgeeks #javascript #programming #learningeveryday #developerjourney

Patterns I hear it repeatedly, "Pick out the patterns." When solving coding problems this definitely rings true. Honestly it rings true in the world of nursing where I was originally from as well. When you sat down at the computer for your nursing license test it did not matter how many questions you practiced and how much of each medical problem you knew. That is not what got me or anyone else through. You have to realize the PATTERN. It was not always what they were asking, but how they were asking it. What details are they purposefully putting in the question or purposefully leaving out. Thinking out the problem, before looking at any answers provided to choose from. Very thankful for other coders who share what they have learned and what worked for them. I hope this post helps someone along their journey like it did me.

🚀 𝗨𝗻𝗹𝗼𝗰𝗸 𝗘𝘅𝗽𝗼𝗻𝗲𝗻𝘁𝗶𝗮𝗹 𝗘𝗳𝗳𝗶𝗰𝗶𝗲𝗻𝗰𝘆: 𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 💡 The Power of 𝗢(𝗹𝗼𝗴 𝗡)! 🤯 Why Binary Search is the ultimate shortcut (and how to write it right). 🧠 Stepping away from the daily count to focus on mastering core algorithms. Today's topic is the single most powerful technique for search efficiency: 𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵. 🎯 When dealing with a 𝘀𝗼𝗿𝘁𝗲𝗱 𝗮𝗿𝗿𝗮𝘆, checking every element (𝗢(𝗡)) is inefficient. Binary Search allows us to drastically cut the search space by half in every step. ⚡ 🔪 𝗧𝗵𝗲 𝗔𝗹𝗴𝗼𝗿𝗶𝘁𝗵𝗺𝗶𝗰 𝗜𝗻𝘀𝗶𝗴𝗵𝘁: 𝗗𝗶𝘃𝗶𝗱𝗲 𝗮𝗻𝗱 𝗖𝗼𝗻𝗾𝘂𝗲𝗿 The magic of 𝗢(𝗹𝗼𝗴 𝗡) comes from this repeated halving. If your array has 𝗡 elements, the number of steps (𝗧) is determined by 𝟮^𝗧 ≈ 𝗡. Solving for 𝗧 gives 𝗧 ≈ 𝗹𝗼𝗴𝟮 𝗡. 💥 𝟭 𝗕𝗶𝗹𝗹𝗶𝗼𝗻 𝗘𝗹𝗲𝗺𝗲𝗻𝘁𝘀 → 𝗙𝗼𝘂𝗻𝗱 𝗶𝗻 𝗷𝘂𝘀𝘁 𝟯𝟬 𝘀𝘁𝗲𝗽𝘀! (Instead of 1 billion). ⚠️ 𝗧𝗵𝗲 𝗣𝗶𝘁𝗳𝗮𝗹𝗹: 𝗟𝗼𝗼𝗽 𝗜𝗻𝘃𝗮𝗿𝗶𝗮𝗻𝘁𝘀 While the concept is simple, writing the bounds correctly is where most developers fail (👋 hello infinite loops!). The key is managing the 𝗹𝗼𝘄 and 𝗵𝗶𝗴𝗵 pointers precisely: ✅ 𝗗𝗲𝗳𝗶𝗻𝗲 𝘁𝗵𝗲 𝗦𝗲𝗮𝗿𝗰𝗵 𝗦𝗽𝗮𝗰𝗲: low = 0, high = N - 1 ✅ 𝗖𝗮𝗹𝗰𝘂𝗹𝗮𝘁𝗲 𝗠𝗶𝗱 𝗦𝗮𝗳𝗲𝗹𝘆: mid = low + Math.floor((high - low) / 2) (prevents overflow and keeps things clean 💻) ✅ 𝗔𝗱𝗷𝘂𝘀𝘁 𝗕𝗼𝘂𝗻𝗱𝘀 𝗪𝗶𝘀𝗲𝗹𝘆: Update bounds based on comparisons — ensure your search space always shrinks 🔁 without skipping the target. 🌱 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆: Binary Search is foundational — the fastest algorithm for searching sorted data and the core idea behind advanced structures like 𝗕𝗶𝗻𝗮𝗿𝘆 𝗦𝗲𝗮𝗿𝗰𝗵 𝗧𝗿𝗲𝗲𝘀 🌳. 💬 What’s your preferred trick for avoiding off-by-one errors when writing Binary Search? Drop your thoughts below! 👇 #DSA #JavaScript #Algorithms #BinarySearch #TimeComplexity #OLogN #CodeOptimization #SoftwareEngineering #InterviewPrep #CodingTips #TechLearning

Today I learned something interesting, I learnt to solve the classic “Single Number” problem: given an array where every element appears twice except one, find the one that appears only once. I initialise result = 0 and XOR it with each number in the array — because a ^ a = 0 and a ^ 0 = a, all duplicates cancel out, leaving the unique number. For example, with [4,2,1,2,4], the process goes: 0 ^ 4 = 4   4 ^ 2 = 6   6 ^ 1 = 7   7 ^ 2 = 5   5 ^ 4 = 1  — and the answer is 1.  What I learned: 1) Bitwise operations (XOR) can give very efficient solutions. 2) Always look at the constraints: “linear time” + “constant space” guided this decision. Even when an approach works, micro-optimisation (loop style, engine behaviour) still affects performance. I’m excited to keep pushing my problem-solving skills and discovering more of these clever tricks. If you’ve got a favourite algorithm or bitwise trick, I’d love to hear it! 💬 #coding #algorithms #javascript #programming #leetcode #learning