Binary Search Insert Position in Java with LeetCode 35

🚀 Day 11 of Java with DSA Journey — This one blew my mind 🤯 📌 Problem: Power of Three (LeetCode 326) Yesterday, I used bit manipulation for Power of Two. Today? 👉 That approach completely fails. So I had to think differently… 💡 Breakthrough Idea Instead of loops or recursion… I used math + number theory to solve it in O(1) time. 👉 1162261467 % n == 0 Yes, one line. 🧠 Key Learnings 🔹 Bitwise isn’t universal Works great for base-2, but not for base-3 🔹 Prime Numbers Matter Since 3 is prime, its powers divide each other perfectly 🔹 Max Value Trick Largest power of 3 in 32-bit int = 3^19 = 1162261467 ⚡ Complexity ⏱ Time: O(1) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Know Your Data Type Limits Many O(1) tricks depend on constraints like 32-bit integer limits 💡 Tip 2: Prime Numbers Unlock Shortcuts If a number is prime, its powers have clean divisibility properties 💡 Tip 3: Always Question the Default Approach Most people write: while (n % 3 == 0) n /= 3; 💡 Tip 4: This is a Pattern Power of 2 → bitwise Power of 3 → math Power of 4 → hybrid 💡 Tip 5: Edge Cases First Always check n <= 0 🔥 Real Insight This problem forced me to shift my thinking: ❌ Rely on one technique ✅ Adapt based on the problem Consistency compounds 📈 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #NumberTheory #InterviewPrep #Day11 #BitManipulation #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

Day 3 of Java with DSA Journey 🚀 📌 Topic: Guess Number Higher or Lower (LeetCode 374) 💬 Quote: "Efficiency is not about doing more; it's about eliminating what doesn't matter." ✨ What I Learned: 🔹 Binary Search Beyond Arrays: Binary Search isn’t limited to arrays — it works perfectly on a number range like [1...n]. 🔹 Working with APIs: Learned how to adapt logic based on API responses: -1 → Guess is too high 1 → Guess is too low 0 → Correct answer 🔹 Power of Efficiency: Even for a huge range (up to 2³¹ - 1), Binary Search finds the answer in ~31 steps 🤯 Compared to Linear Search → practically impossible! 🔹 Complexity: ⏱ Time: O(log n) 📦 Space: O(1) 🧠 Problem Solved: ✔️ Guess Number Higher or Lower 💡 Key Insight: This problem highlights the “Narrowing the Search Space” concept. Each step eliminates half the possibilities — that’s the magic of logarithmic algorithms ⚡ ⚡ Interview Insight (3-Way Decision Logic): Unlike boundary problems, here we deal with three outcomes: 1️⃣ 0 → Found the number (return immediately) 2️⃣ -1 → Move right = mid - 1 3️⃣ 1 → Move left = mid + 1 👉 Use while (left <= right) since the target is guaranteed to exist. 🔑 Takeaway: Consistency beats intensity. Showing up daily is what builds mastery. #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #100DaysOfCode #JavaDeveloper #Algorithms

Day 7 of Java with DSA Journey 🚀 📌 Topic: Missing Number (LeetCode 268) Quote: "Sometimes the best way to solve a coding problem is to put down the keyboard and pick up a calculator." ✨ What I learned today: 🔹 Mathematical Optimization: Instead of brute force, I used a simple formula to compute the expected sum. {Sum} = \frac{n(n+1)}{2} 🔹 Core Idea: Expected Sum − Actual Sum = Missing Number 🔹 Alternative Approach: Used XOR technique where duplicates cancel out → leaving the missing value. 🔹 Efficiency: ✔️ Time Complexity: O(n) ✔️ Space Complexity: O(1) 🧠 Problem Solved: ✔️ Missing Number 💡 Key Insight: We often jump to HashSet or Sorting, but this problem taught me to pause and think mathematically first. A simple formula reduced space complexity from O(n) → O(1) 🚀 ⚡ Interview Tip (Important!): Be careful of integer overflow in Java: n * (n + 1) can exceed int limit Use long OR switch to XOR method for safety Consistency is the real key 🔑 #DSA #LeetCode #Java #Mathematics #CodingJourney #ProblemSolving #Day7 #Algorithms #Optimization #Array #MCA #lnct #100DaysOfCode #Algorithms #SoftwareEngineering #InPlaceAlgorithms #TechLearning #JavaDeveloper

🚀 DAY 99/150 — BINARY SEARCH ON ANSWER! 🔥📊 Day 99 of my 150 Days DSA Challenge in Java and today I solved a very important problem that uses Binary Search in a 2D matrix 💻🧠 📌 Problem Solved: Kth Smallest Element in a Sorted Matrix 📌 LeetCode: #378 📌 Difficulty: Medium–Hard 🔹 Problem Insight The task is to find the kth smallest element in an n x n matrix where: • Each row is sorted • Each column is sorted 👉 Instead of flattening and sorting (O(n² log n)), we can do better using Binary Search on Answer. 🔹 Approach Used I used Binary Search on Value Range: • Set: low = smallest element high = largest element • Apply binary search: Find mid Count how many elements are ≤ mid 👉 If count < k → move right (low = mid + 1) 👉 Else → move left (high = mid) ✔️ Continue until low == high → answer found 🔹 Counting Logic (Optimized) • Start from bottom-left corner • If element ≤ mid: All elements above are also ≤ mid Move right • Else: Move up ✔️ This gives O(n) counting per iteration ⏱ Complexity Time Complexity: O(n log (max - min)) Space Complexity: O(1) 🧠 What I Learned • Binary Search is not just for arrays — it can be applied on answer space • Matrix properties can be used for efficient counting • Avoid brute force by leveraging sorted structure 💡 Key Takeaway This problem taught me: How to apply Binary Search on Answer pattern How to optimize 2D problems using structure Thinking beyond direct sorting approaches 🌱 Learning Insight Now I’m improving at: 👉 Recognizing when to use Binary Search beyond arrays 👉 Solving problems with optimized thinking 🚀 ✅ Day 99 completed 🚀 51 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/g-yhc7kH 💡 Don’t search the data — search the answer. #DSAChallenge #Java #LeetCode #BinarySearch #Matrix #Optimization #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

Day 10 of Java DSA Journey 🚀 📌 Problem: Power of Two (LeetCode 231) Most people solve this using loops: ➡️ Keep dividing by 2 until you reach 1 But today I learned something better: 👉 You can solve it in ONE line using bit manipulation 🤯 💡 Core Idea A number is a power of two if: ✔️ It has only one ‘1’ in its binary form Examples: 1 → 0001 2 → 0010 4 → 0100 16 → 10000 🧠 The Magic Trick 👉 n & (n - 1) This removes the rightmost set bit So: If result = 0 → only one bit was set → ✅ Power of Two Else → ❌ Not a power of two ⚡ Complexity ⏱ Time: O(1) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Always Check Positivity First n > 0 is mandatory — bit tricks fail for negative numbers. 💡 Tip 2: Understand, Don’t Memorize n - 1 flips: the rightmost 1 → 0 all bits after it → 1 That’s why the trick works. 💡 Tip 3: This Pattern Appears Everywhere The same trick is used in: Counting set bits Subset generation Low-level optimizations 👉 Learn it once, reuse forever. 💡 Tip 4: Alternative Trick (Even Cleaner) Another way: 👉 (n & -n) == n This isolates the lowest set bit. If it's equal to n, only one bit exists. 💡 Tip 5: Bitwise = Senior-Level Thinking Using bit manipulation shows: ✔️ You understand how data is stored ✔️ You can optimize beyond brute force 🔥 Real Insight This problem is not about checking powers… It’s about recognizing: 👉 Patterns in binary representation Once you see that, the solution becomes obvious. Consistency builds mastery 🔑 #DSA #LeetCode #Java #BitManipulation #CodingJourney #ProblemSolving #InterviewPrep #Day10 #BitManipulation #InterviewPrep #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

Day 9.2 of Java with DSA Journey 🚀 📌 Problem: Number of Steps to Reduce a Number to Zero (LeetCode 1342) At first glance, this looks too easy… But hidden inside is a powerful idea: 👉 Thinking in binary instead of decimal 💡 Core Idea Keep reducing the number until it becomes 0: Even → divide by 2 Odd → subtract 1 Simple rule. Powerful pattern. 🧠 Key Learnings 🔹 Iterative Thinking Used a loop to repeatedly transform the state 🔹 Decision Making per Step Even vs Odd → determines next move 🔹 Bitwise Insight num % 2 == 0 → (num & 1) == 0 num / 2 → num >> 1 ⚡ Complexity ⏱ Time: O(log n) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Think in Binary, Not Decimal Every division by 2 removes one bit → that's why complexity is logarithmic. 💡 Tip 2: Count Operations Without Simulation Steps = 👉 (Number of bits - 1) + (Number of 1s in binary) Example: 14 → 1110 Steps = (4 - 1) + 3 = 6 💡 Tip 3: Bitwise > Arithmetic (When Optimizing) Replace: % 2 → & 1 / 2 → >> 1 This shows low-level understanding. 💡 Tip 4: Pattern Recognition Matters This problem is not about loops… It’s about recognizing bit reduction patterns. 💡 Tip 5: Always Look for Hidden Math Even simple problems often have a mathematical shortcut behind them. 🔥 Real Insight This problem teaches a subtle shift: ❌ “Keep applying rules” ✅ “Understand what each operation does to the binary structure” That’s how you move from coding → engineering. Consistency compounds 📈 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #Day9 #BitManipulation #InterviewPrep #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

Day 7.2 of Java with DSA Journey 🚀 📌 Topic: Find All Numbers Disappeared in an Array (LeetCode 448) Quote: "Constraints are not limitations—they are invitations to think smarter." ✨ What I learned today: 🔹 In-Place Hashing (Pro Trick): When extra space is restricted, the input array itself can act like a HashMap. 🔹 Index Mapping Insight: Since values are in range [1, n], each number maps to an index: 👉 index = value - 1 🔹 Sign Flipping Technique: Mark elements as “visited” by flipping the value at the mapped index to negative. ✔️ Negative → already seen ✔️ Positive → missing number 🔹 Efficiency: ✔️ Time Complexity: O(n) ✔️ Space Complexity: O(1) (No extra data structures used!) 🧠 Problem Solved: ✔️ Find All Numbers Disappeared in an Array 💡 Key Insight: This problem completely changed how I look at arrays. Instead of using extra memory like HashSet, I learned how to store state inside the array itself. That’s a powerful mindset shift for interviews 🚀 ⚡ Interview Insight (High-Value Pattern): Whenever you see: Numbers in range [1, n] or [0, n] Need to find missing / duplicate elements Constraint of O(1) space 👉 Think Index as Hash Key This is a top-tier pattern asked in product-based companies. Consistency is the real key 🔑 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #Algorithms #Array #InterviewPrep #Optimization #Day8 ##MCA #lnct #100DaysOfCode #SoftwareEngineering #InPlaceAlgorithms #TechLearning #JavaDeveloper

🚀 Learning Java the Right Way Today, I practiced an interesting DSA problem — 👉 Find Peak Element (Using Binary Search) 📌 Problem: Find an element in an array that is greater than its neighbors. Example: Array → {1, 3, 20, 4, 1, 0} Output → 20 ✅ 🔹 Key Learning: Instead of using a linear approach (O(n)), I solved it using Binary Search in O(log n) by analyzing the slope of the array. 📌 Approach: Compare mid with mid + 1 If increasing → move right If decreasing → move left Peak is found when both sides are smaller This problem helped me understand: ✔ Advanced Binary Search application ✔ Logical decision making ✔ Optimization techniques ✔ Pattern recognition in arrays Not every Binary Search problem is straightforward — adapting it to different patterns is the real skill 💪 📌 Think smart • Analyze patterns • Optimize solutions 🚀 #java #javafullstack #javadeveloper #corejava #codingjourney #coding

🚀 Day 11.2 of Java DSA Journey — Trilogy Complete 🧠⚡ 📌 Problem: Power of Four (LeetCode 342) I didn’t just solve this problem… 👉 I connected everything from the last days: Power of 2 → Bitwise Power of 3 → Math Power of 4 → Both combined 💡 Breakthrough Idea To be a power of four, a number must: ✔️ Be positive ✔️ Be a power of two → (n & (n - 1)) == 0 ✔️ Follow a math rule → (n - 1) % 3 == 0 👉 That’s a multi-layered check in O(1) 🧠 Key Learnings 🔹 Not all powers of 2 are powers of 4 (Example: 8, 32 ❌) 🔹 Mathematical Signature Matters For every 4^x, (n - 1) is divisible by 3 🔹 Combining Concepts = Real Growth Bitwise + Math → Cleaner, faster solution ⚡ Complexity ⏱ Time: O(1) 📦 Space: O(1) 🔥 Pro Tips (Interview Level) 💡 Tip 1: Layer Your Conditions Break complex checks into smaller logical filters 💡 Tip 2: Don’t Stop at Bitwise Sometimes bit tricks need math support 💡 Tip 3: Know Alternative Tricks 👉 0x55555555 mask can validate correct bit position 💡 Tip 4: Pattern Recognition is Everything This entire trilogy is about identifying patterns in numbers 💡 Tip 5: Think Like an Engineer Combine approaches instead of forcing one technique 🔥 Real Insight This wasn’t just a problem… It was about learning: 👉 When to use bitwise 👉 When to use math 👉 When to combine both That’s real problem-solving. Consistency builds mastery 📈 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #InterviewPrep #Day11 #BitManipulation #InterviewPrep #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

🚀 Day 2 of Java with DSA Journey 📌 Topic: First Bad Version (LeetCode 278) 💬 Quote of the Day: "Binary Search isn't just an algorithm; it's a mindset of elimination over inspection." ✨ What I learned: 🔹 Beyond Arrays: Binary Search works on any monotonic search space—not just arrays 🔹 Boundary Thinking: Focus shifted from finding a value to identifying the first occurrence of a condition 🔹 Implementation: Used left < right to precisely converge on the boundary 🔹 Time Complexity: O(log n) | Space Complexity: O(1) 🔹 Common Mistake: Using right = mid - 1 and skipping the correct answer 🔹 Real-World Use: Debugging systems, version control tools (like finding breaking commits) 🔹 Optimization: Reduced expensive API calls by halving the search space 🔹 Alternative Approach: Linear scan (O(n)) but inefficient 🧠 Problem Solved: ✔️ First Bad Version 💡 Insight: Binary Search is not just about searching—it’s about identifying boundaries efficiently. This shift in thinking is crucial for solving real interview problems. ⚡ Interview Insight: If mid is bad, it might be the first bad version → so we keep it: 👉 right = mid (NOT mid - 1) This small detail makes a huge difference in correctness. Consistency is the real key 🔑 #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #Day2 #SoftwareEngineering #MCA #lnct