Array Problem Solving Strategy in Java

🚀 Day 10 of #100DaysOfDSA – Solved LeetCode 344: Reverse String Today’s problem was simple yet powerful — Reverse a String (in-place) 💡 🔹 Problem: Given a character array, reverse it without using extra space. 🔹 Approach: Used the Two Pointer Technique: 👉 Start one pointer from the beginning 👉 Another from the end 👉 Swap characters and move inward 🔹 Key Learning: In-place operations improve space efficiency Two-pointer approach is a must-know pattern for interviews 🔹 Time Complexity: O(n) 🔹 Space Complexity: O(1) 💻 Code Insight: Swapping elements until both pointers meet does the job efficiently! ✨ Small problems like this build strong fundamentals for bigger challenges. #DSA #Java #Coding #LeetCode #Programming #SoftwareEngineering #InterviewPrep #100DaysOfCode

Most programmers don’t fail because of logic—they fail because of inefficiency when constraints are tight. In competitive programming and during contests in CodeForces, LeetCode, etc., computing (a^k mod m) naively is a silent performance killer. What looks trivial quickly turns into Time Limit Exceeded when constraints scale. This is where thinking in terms of optimization—not just correctness—separates average from strong performers. Most people know this technique of Fernat's little theorem—but fail to apply it under pressure, and don't even know that it can be extended to non-primes as well. Competitive programming is less about memorising tricks and more about triggering the right pattern at the right time. Trade-off to internalize: • Naive → Simple but slow • Optimised → Slightly complex but scalable This thinking directly translates to real systems—efficient algorithms reduce latency, cost, and compute overhead at scale. Do you recognize patterns fast enough when it actually matters? Follow Vishu Kalier for more such insights. #CompetitiveProgramming #Algorithms #Coding #ProblemSolving #TimeComplexity #SystemDesign #DSA #Java #cfbr #Eternal #Codeforces #leetcode #fernattheorem

Day 13/90 DSA Journey Today I worked on an interesting problem where each bulb toggles between ON and OFF based on its occurrences in the input list. ->Key Idea: If a number appears odd number of times → bulb remains ON If it appears even number of times → bulb turns OFF -> Approach: Used a List-based toggle logic Add element if not present Remove element if already present Finally, sort the result -> Time Complexity: O(n²) using List (due to contains & remove) -> Optimized Insight: This problem can be solved more efficiently using a HashSet in O(n) time. -> Takeaway: Understanding frequency and toggling patterns is very useful in solving real-world and DSA problems. #LeetCode #DSA #Java #Coding #ProblemSolving #Learning #TechJourney

Day 75 of My DSA Journey Today’s problem: Reverse Bits (LeetCode 190) At first glance, it looks simple—but it really tests your understanding of bit manipulation 🔹 What I learned today: • How to extract the last bit using n & 1 • Building a reversed number using left shift • Importance of running exactly 32 iterations (handling leading zeros!) • Thinking in terms of binary, not decimal 🔹 Key Idea: Take bits from right to left and rebuild the number from left to right. 💡 This problem helped me get more comfortable with low-level operations—something that’s super useful for writing efficient code. 📈 Progress Update: 75 days of consistency! Small steps every day are building strong problem-solving skills #DSA #100DaysOfCode #Java #CodingJourney #LeetCode #BitManipulation #Consistency #Learning

🚀 Day 69/100 – DSA Challenge Another day, another step closer to mastery 💯 Today’s problem was about finding the maximum distance between two houses with different colors. 🔍 Problem: Given an array where each element represents the color of a house, find the maximum distance between two houses such that their colors are different. 🧠 Approach: Instead of checking all pairs (which would be inefficient), the key idea is: Compare elements from the start with the end Find the farthest positions where colors differ Maximize the distance using smart observations rather than brute force 💡 Key Insight: The maximum distance will always involve either the first or the last house — this reduces the problem from quadratic to linear time. ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) 📌 Learning: This problem reinforced how identifying patterns and constraints can help avoid brute force and lead to optimal solutions. Consistency streak continues 🔥 On to Day 70 🚀 #100DaysOfCode #DSA #Java #ProblemSolving #Consistency #CodingJourney #KeepLearning

Day 55 of 100 Days of LeetCode 💻 Today I solved Longest Consecutive Sequence — and honestly, this one taught me more about coding discipline than algorithms. At first, my approach was correct: Used HashSet for O(1) lookup Applied the “start of sequence” logic But I still got TLE. The reason? A tiny mistake: if(!set.contains(num-1)); That single ; made my condition useless and turned my O(n) solution into O(n²). 💡 Lesson learned: Don’t just think your logic is right → verify what your code actually does Small syntax mistakes can completely break optimal solutions Debugging is just as important as problem-solving Finally fixed it and got Accepted ✅ Slowly improving not just in DSA, but in writing cleaner and more careful code. #100DaysOfLeetCode #DSA #Java #CodingJourney #Learning

At first, the Rotate Image problem looked tricky. Rotating a matrix in-place isn’t something that feels obvious right away. But after thinking about it, I realized it’s not about rotation directly, it’s about transforming the matrix step by step. By first flipping it across the diagonal (transpose) and then reversing each row, the rotation happens naturally. Moments like this remind me that in coding, the right approach often matters more than the problem itself. Learning to break problems down is the real skill. RAVI KUMAR Coding Blocks Sunstone #Coding #DSA #Java #ProblemSolving #GrowthMindset #Learning

Solved: Count Number of Factors of N (DSA) Today I worked on a classic problem — finding the number of divisors of a number. 🔹 Started with a basic approach: O(N) 🔹 Optimized it to: O(√N) using divisor pairs 💡 Key Insight: Every divisor i has a corresponding pair N/i, which helps reduce the number of iterations significantly. Also handled the edge case of perfect squares carefully ✔️ This is a small problem, but it builds strong fundamentals for: Number Theory Competitive Programming Technical Interviews Would love feedback from the community 🙌 #DSA #Java #Coding #ProblemSolving #SoftwareEngineering #LearningInPublic

🚀 Day 109 DSA Problem Solving 📌 Problem Solved: Maximum Distance Between a Pair of Values 💡 Level: Medium 🧠 Problem Idea Given two non-increasing arrays, find the maximum distance (j - i) such that: i ≤ j nums1[i] ≤ nums2[j] 🔍 Key Learning Today reinforced a powerful pattern: 👉 When arrays are sorted, always think about Two Pointers before brute force. ⚙️ Approach Used Used Two Pointers (i, j) If condition satisfies → expand j to maximize distance Else → move i to find a smaller value ⏱ Time Complexity O(n + m) ✅ (No nested loops, super efficient) 💭 Real Journey Behind the Solution Initially, I thought about checking all pairs (brute force), but that would lead to TLE. Then I noticed both arrays are non-increasing, which unlocked the two-pointer optimization. This is a reminder that: 👉 Observing constraints carefully can completely change the approach. 📈 Concepts Practiced Two Pointers Greedy Thinking Array Traversal Optimization 🔥 Takeaway Not every problem needs complex logic—sometimes the smartest solution is just about moving pointers wisely. #Day109 #DSAJourney #LeetCode #Coding #Java #ProblemSolving

Day 53 of #100DaysOfCode Didn’t post after Day 7… not because I stopped — but because I got deeper into the process. Some problems don’t take hours, they take days. And honestly, that’s where the real growth happens. So far: ✔️ 25 problems solved ✔️ Countless hours of thinking, debugging, and rethinking One thing I’ve realized (something not many people talk about): Most DSA questions aren’t about knowing the solution — they’re about recognizing the *pattern*. But here’s the catch— The same pattern can appear in completely different forms, and unless you’ve struggled with it before, you won’t even recognize it. That’s why sometimes a single question can take 2–3 days — not because it’s “hard”, but because it’s *teaching you how to think*. I’ve started noticing: • Many problems are just variations of a few core ideas (two pointers, sliding window, hashing, recursion) • The difficulty lies in identifying *which lens to use* Still learning. Still showing up. Consistency isn’t loud — it’s quiet and repetitive. On to Day 100 💪 #DSA #LeetCode #Consistency #ProblemSolving #Java