Java Debugging: Reverse String Prefix Challenge

🚀 A tiny mistake. A big lesson in Java. Recently while debugging a DSA solution, I ran into this condition: while(nums1[p1] == res[i-1] && p1 < n1) Looks perfectly fine at first glance, right? But Java evaluates left to right. So what actually happens is: nums1[p1] == res[i-1] // evaluated FIRST And only after that: p1 < n1 If p1 == n1, the code tries to access nums1[n1] → 💥 ArrayIndexOutOfBoundsException The fix? Just change the order: while(p1 < n1 && nums1[p1] == res[i-1]) Now bounds are checked before access. Safe. Correct. Stable. 🧠 Real lesson here: This wasn’t about syntax. This wasn’t about logic. This was about execution order. Small details in code structure can break entire algorithms. 💡 Takeaways: • Code is not just about what you write • It’s about how the compiler reads it • Order of conditions matters • Evaluation order matters • Safety checks must always come first • Clean logic must also be safe logic This one bug reminded me that: Great code isn’t just correct — it’s defensively written. The difference between a good developer and a strong developer is often attention to tiny details like these. Because in real systems, small mistakes don’t fail small — they fail big. #Java #DSA #Debugging #ProblemSolving #CleanCode #ProgrammingLessons #SoftwareEngineering #LearningByDoing #DeveloperLife #GrowthMindset

✨DAY-13: 🔁 Polymorphism in Java – Same Method, Different Behavior! This image perfectly explains one of the most powerful concepts in OOP — Polymorphism 👇 🐾 Base Class: Animal() 🐶 Derived Classes: Dog() and Cat() The programmer simply says: 👉 “Objects, do your thing!” 😎 And what happens? 🐕 Dog responds: “Woof! Woof!” 🐈 Cat responds: “Meow!” Same method call. Different outputs. That’s the beauty of runtime polymorphism (method overriding) in Java. 💡 Technical Insight: When we use a parent class reference like: Animal obj = new Dog(); obj.sound(); Java decides at runtime which method to execute. This is called Dynamic Method Dispatch. 📌 Why Polymorphism Matters: Increases flexibility Improves scalability Promotes clean and maintainable code Follows the “program to interface, not implementation” principle In simple terms: You give the same command… But each object responds in its own way. That’s real-world programming power. 💻🔥 #Java #OOP #Polymorphism #Programming #SoftwareDevelopment #CodingLife #TechConcepts

✨DAY-13: 🔁 Polymorphism in Java – Same Method, Different Behavior! This image perfectly explains one of the most powerful concepts in OOP — Polymorphism 👇 🐾 Base Class: Animal() 🐶 Derived Classes: Dog() and Cat() The programmer simply says: 👉 “Objects, do your thing!” 😎 And what happens? 🐕 Dog responds: “Woof! Woof!” 🐈 Cat responds: “Meow!” Same method call. Different outputs. That’s the beauty of runtime polymorphism (method overriding) in Java. 💡 Technical Insight: When we use a parent class reference like: Animal obj = new Dog(); obj.sound(); Java decides at runtime which method to execute. This is called Dynamic Method Dispatch. 📌 Why Polymorphism Matters: Increases flexibility Improves scalability Promotes clean and maintainable code Follows the “program to interface, not implementation” principle In simple terms: You give the same command… But each object responds in its own way. That’s real-world programming power. 💻🔥 #Java #OOP #Polymorphism #Programming #SoftwareDevelopment #CodingLife #TechConcepts #Developers

🚀 3 Ways to Solve Maximum Subarray Sum (Size K) in Java Today I practiced solving a common DSA problem in Java: 👉 Find the maximum sum of a subarray of size K (K = 3) Array: {5, 9, 1, 8, 7} 9+1+8=18 Instead of jumping directly to the optimal solution, I solved it in three different ways to understand the improvement step by step. ✅ 1️⃣ Way 1 – O(n³) (Brute Force) Generate all possible subarrays Check if size equals K Calculate sum ✔ Good for understanding basics ❌ Very slow (3 nested loops) ✅ 2️⃣ Way 2 – O(n²) (Improved) Fix starting index Directly calculate sum of next K elements ✔ Reduced one loop ✔ Better than brute force ✅ 3️⃣ Way 3 – O(n) (Sliding Window) 🔥 Maintain a running window sum Add next element Remove first element when window exceeds size K Update maximum ✔ Most efficient ✔ Interview-friendly ✔ Real-world optimized approach 💡 Key Learning Optimization is not magic. It’s about improving step by step: O(n³) → O(n²) → O(n) Understanding this transition is what truly builds problem-solving skills. I’m continuously improving my Data Structures & Algorithms skills as a Java learner 💻🔥 #Java #DSA #SlidingWindow #ProblemSolving #CodingPractice #JavaDeveloper #LearningJourney

✨DAY-16: 💻 From Messy Variables to Clean Arrays – The Power of Smart Coding! This meme perfectly shows the difference between writing code without arrays and using arrays in Java. 🔴 Without Arrays: Java Copy code int mark1 = 86; int mark2 = 71; int mark3 = 90; int mark4 = 65; 👉 Too many variables 👉 Hard to manage 👉 Not scalable 👉 Messy and inefficient Imagine handling 100 student marks like this 😅 🟢 With Arrays: int[] marks = {86, 71, 90, 65, 79}; ✅ Organized ✅ Easy to access using index ✅ Simple to loop ✅ Clean and scalable Arrays help us store multiple values of the same type in a single variable, making our code structured and efficient. 📌 Daily Life Lesson: When things are unorganized, life feels stressful. When structured properly, everything becomes simple and productive. Learn concepts clearly — code smarter, not harder 🚀 #Java #Programming #Arrays #CodingLife

Writing methods is powerful. But real Java begins when you understand classes. A class is not just a file. It’s a blueprint. When you write: public class Car { String model; int speed; void accelerate() { speed++; } } You’re defining: • What something has (state / fields) • What something does (behavior / methods) That’s object-oriented thinking. Instead of writing loose functions, you start modeling real-world entities. This shift matters. Procedural thinking asks: “How do I solve this step by step?” Object-oriented thinking asks: “What is responsible for this behavior?” That small shift improves: • Code organization • Scalability • Maintainability Today was about: • Understanding what a class really represents • The difference between state and behavior • Thinking in objects instead of instructions Structure is not restriction. It’s preparation for complexity. #Java #OOP #Classes #SoftwareDesign #Programming #LearningInPublic

Day 23 of problem solving– Valid Anagram | DSA in Java Today I solved the “Valid Anagram” problem. Problem Statement: Given two strings s and t, return true if t is an anagram of s, and false otherwise. 🔹 An anagram means both strings contain the same characters with the same frequency. Approach I Used: Instead of sorting both strings (which takes O(n log n)), I used a frequency array technique for better performance. Logic: If lengths are different → return false. Create an integer array of size 26. Increase count for characters in first string. Decrease count for characters in second string. If all values are zero → it’s a valid anagram. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) (Fixed size array) 📌 Key Learning: Using a frequency counter is more efficient than sorting when dealing with character-based problems. Consistency > Motivation Slowly building problem-solving strength every day. #DSA #Java #100DaysOfCode #CodingJourney #SoftwareEngineer

Dynamic typing vs static typing! What are your thoughts? As a new programmer dynamic typing feels flexible and powerful. Languages like Python feel user friendly and productive. however, as the systems you are designing become more complex, things need to be more explicit. Interfaces and boundaries need to be clear and rigidity becomes an assert. As much as I disliked Java's boilerplate and camel case variables, coupled with Spring's convoluted indirection, I have to admit that the duo shines when you need to fight with complexity. Rust would be better if it had more mature libraries and a better ecosystem. I am watching it though.

Leetcode problem No : 345 🚀 Mastering Two-Pointer Technique in Java — Reverse Vowels Problem Today I practiced a classic two-pointer algorithm by solving the “Reverse Vowels of a String” problem in Java. The core idea is simple but powerful: 👉 Use two indices — one from the start and one from the end — and move them toward each other while swapping only the target characters (vowels in this case). 💡 Key Learning Points: ✅ How to convert a string into a mutable character array ✅ Efficient character checking using a helper function (isVowel) ✅ Optimized time complexity O(n) with constant extra space ✅ Clean pointer movement logic to avoid unnecessary operations This approach is widely used in: String manipulation problems Array partitioning Palindrome checks Competitive programming & coding interviews Practicing these patterns consistently builds strong problem-solving intuition. Small problems like this create the foundation for solving much harder algorithm challenges later. If you’re learning Data Structures & Algorithms, remember: Consistency beats complexity. Solve daily, even if it’s small. 🔥 What was the last algorithm pattern you practiced? #Java #DSA #CodingInterview #TwoPointer #Programming #SoftwareEngineering #LeetCode #ProblemSolving #Developers #CodingJourney #TechCareer

Streams vs for-loop in Java 👇 Streams look modern. for-loops look boring. But in real code… boring often wins. ✅ Use Streams when: • Logic is simple • Code reads like English • You’re just transforming data users.stream() .map(User::getName) .toList(); ✅ Use for-loop when: • Logic gets tricky • You need break / continue • Debugging step-by-step helps for (User user : users) { if (user.isBlocked()) break; } ❌ Streams aren’t always cleaner. Nested lambdas can hide logic. 💡 My rule: If a stream makes you pause, a for-loop is the better choice. Readability > cleverness. Team Streams or Team for-loop? 👇🔥 #Java #CleanCode #BackendDevelopment #Programming #SoftwareEngineering