Max Consecutive Ones in Java with DSA

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 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 9 of Java with DSA Journey 🚀 📌 Problem: Palindrome Number (LeetCode 9) Most people solve this like beginners: ➡️ Convert number → String → Reverse → Compare But today I challenged myself: 👉 Can I solve this without using extra space? 💡 Breakthrough Moment Instead of reversing the whole number… I reversed only HALF of it 🤯 Why this matters: ✔️ Prevents integer overflow ✔️ Uses O(1) space ✔️ More optimized & interview-ready 🧠 Key Learnings 🔹 Math > Shortcuts Using % and / gives complete control over digits 🔹 Half-Reversal Trick Stop when reversed ≥ original → you've reached the middle 🔹 Edge Case Awareness ❌ Negative numbers ❌ Numbers ending in 0 (except 0 itself) ⚡ Complexity ⏱ Time: O(log₁₀ n) 📦 Space: O(1) 🔥 Pro Tips (Real Interview Insights) 💡 Tip 1: Think Beyond the Obvious If a problem mentions "without string", it's testing your number manipulation skills, not syntax. 💡 Tip 2: Avoid Full Reversal When Possible Reversing the entire number can cause overflow for large inputs. 👉 Reversing half is both safer and smarter. 💡 Tip 3: Always Question Edge Cases First Before coding, ask: What about negative numbers? What about trailing zeros? This saves debugging time later. 💡 Tip 4: Optimize Space by Default Interviewers notice when you avoid unnecessary structures like Strings or Arrays. 💡 Tip 5: Stop Early (Hidden Optimization) Breaking the loop at midpoint reduces operations — small detail, big impact. 🔥 Real Insight Anyone can solve problems using strings. But solving it mathematically proves you understand: ✔️ Data representation ✔️ Constraints ✔️ System limitations That’s what separates coders from engineers. Consistency > Motivation 🔑 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #InterviewPrep #Day9 #CleanCode #Array #Optimization #MCA #lnct #100DaysOfCode #SoftwareEngineering #Algorithms #InPlaceAlgorithms #TechLearning #JavaDeveloper

Day 10.2 of Java with DSA Journey 🚀 📌 Problem: Base 7 Conversion (LeetCode 504) At first, this looks like a simple math problem… But it actually teaches something deeper: 👉 How numbers are built in different systems 💡 Core Idea To convert a number from base 10 → base 7: Divide by 7 Store remainder Repeat until 0 Reverse the result 🧠 Key Learnings 🔹 Understanding Number Systems Decimal (base 10) is just one system—this logic works for ANY base 🔹 Modulo + Division Pattern num % base → current digit num / base → move to next position 🔹 Why Reverse? We generate digits from least significant → most significant ⚡ Complexity ⏱ Time: O(log₇ n) 📦 Space: O(log₇ n) 🔥 Pro Tips (Interview Level) 💡 Tip 1: This is a Universal Pattern This exact logic works for: Binary (base 2) Octal (base 8) Hex (base 16) 👉 Learn once, apply everywhere. 💡 Tip 2: Handle Negatives Separately Always convert using abs(num) and attach - later This avoids tricky modulo behavior. 💡 Tip 3: Avoid String Concatenation in Loops Use StringBuilder 👉 Shows awareness of time complexity + memory efficiency 💡 Tip 4: Reverse Thinking = Interview Gold If you're building output backward → think reverse at the end 💡 Tip 5: Hidden Optimization Insight If allowed, you could also: Use recursion → cleaner logic Or pre-calculate size for optimization 🔥 Real Insight This problem is not about Base 7… It’s about understanding: 👉 How computers represent and transform numbers internally Once you master this, you can convert between any number systems. Consistency builds depth 📈 #DSA #LeetCode #Java #CodingJourney #ProblemSolving #Algorithms #MathLogic #Day10 #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

Day 4 of Java with DSA Journey 🚀 📌 Topic: Search Insert Position (LeetCode 35) 💬 Quote: "Binary Search is about more than finding a needle in a haystack; it's about knowing exactly where to put a new needle." ✨ What I Learned: 🔹 Power of the low Pointer: If the target isn’t found, low directly gives the correct insertion index. 🔹 Finding Position Even When Missing: Binary Search doesn’t just search — it tells you where the element belongs. 🔹 Efficient Gap Detection: Even for missing values, we maintain O(log n) efficiency. 🔹 Complexity: ⏱ Time: O(log n) 📦 Space: O(1) 🧠 Problem Solved: ✔️ Search Insert Position 💡 Key Insight: Binary Search helps determine the rank/position of a number in a sorted array — whether it exists or not ⚡ ⚡ Interview Insight (Post-Loop Behavior): 👉 When the loop ends (low > high): low → first index greater than target high → last index smaller than target 🎯 That’s why low = insert position 🔑 Takeaway: Binary Search is not just about finding — it's about positioning. Consistency is the real key 🔑 #DSA #LeetCode #Java #CodingJourney #BinarySearch #ProblemSolving #100DaysOfCode #Algorithms #TechLearning #Day4 #Array #MCA #lnct

🚀 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 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 1 of Java with DSA Journey 📌 Topic: Binary Search (LeetCode 704) 💬 “Today I practiced a very fundamental problem from LeetCode.” Today was all about efficiency and smart problem solving. While Linear Search checks every element one by one, Binary Search drastically reduces the search space by half in each step — making it one of the most powerful techniques in DSA. ✨ What I Learned: 🔹 Divide & Conquer: Reducing the problem size at every step leads to faster solutions 🔹 Prerequisite: Works only on sorted arrays 🔹 Implementation: Used iterative approach with two pointers (low & high) 🔹 Time Complexity: O(log n) | Space Complexity: O(1) 🔹 Common Mistake: Wrong mid calculation or improper pointer updates causing infinite loops 🔹 Real-World Use: Search engines, databases, efficient lookup systems 🔹 Optimization Insight: Much faster than Linear Search (O(n)) for large datasets 💡 Pro Tip (Java Developers): Always calculate mid like this: mid = low + (high - low) / 2; 👉 Prevents integer overflow and makes your code production-ready. 🧠 Performance Insight: ✔️ Linear Search: If you have 1 million elements, you might check 1 million times. ✔️ Binary Search: For that same 1 million elements, you only need 20 checks max. That’s the power of optimization ⚡ 💡 Insight: Understanding how to reduce problem size is the key to writing efficient algorithms. Even the simplest problems build the strongest foundation. Consistency is the real key 🔑 #DSA #Java #LeetCode #CodingJourney #BinarySearch #ProblemSolving #SoftwareEngineering #Day1