Today marks Day 27 of my Java learning journey — and today, I focused on solving the problem of removing duplicates from a sorted array using an optimized in-place approach — without using any extra space. Instead of creating a new array, I applied the two-pointer technique — one pointer to traverse (read) through the array and another to track (write) the position where the next unique element should be placed. Each time a new distinct value appeared, it was written at the current write index, effectively overwriting duplicates as the array was scanned. This approach reduced the space complexity to O(1) while maintaining a clean O(n) time complexity. What made this problem truly interesting was how a small change in perspective — using two moving pointers instead of nested loops — made the solution both elegant and efficient. It was a great reminder that optimization often lies in logic, not in length of code. 💡 #Java #Day27 #LearningJourney #Programming #Coding #ProblemSolving #DataStructures #Algorithms #LogicBuilding #Optimization #SoftwareDevelopment #Efficiency #TwoPointers

Today marks Day 25 of my Java learning journey — and today's topic took my understanding of array traversal and pattern detection a step further! I explored how to find the smallest and largest repeating elements in a sorted array, but this time, by traversing from the last element to the first — a reverse approach that really deepened my logic-building skills. In most array problems, we move from start to end, but reversing the direction helps us analyze problems differently. While implementing this logic, I learned how: Reverse traversal can directly identify the largest repeating element first, saving time in certain cases. The smallest repeating element can still be determined efficiently while looping backward. Writing separate methods (functions) improves readability and makes the code modular, reusable, and easy to test. This exercise reminded me that in programming, sometimes changing the direction of thought — quite literally — opens up a new perspective for optimization. 🔁💡 #Java #Day25 #Programming #LearningJourney #Coding #SoftwareDevelopment #Arrays #ProblemSolving #LogicBuilding #ReverseTraversal #DataStructures #LearningEveryday

Like every language, Rust also has loop system to iterate over array. In my Rust learning journey, I found many similarities between Java and Rust in terms loops and there are also a new kind of loop in Rust. . Like java, Rust has for-loop, for-each loop, while loop. . Rust has a new kind of loop called "loop" that is equivalent to "while(true)" in java. Rust doesn't have do-while but it can be achieved with while loop. . #programming #java #rust #developer #coding #backendDevelopment #SoftwareEngineering #learning #coding

Day(11/30)| Java Problem Solving Series Today I practiced an interesting problem — Check if a number is a Palindrome At first, my logic had a small mistake I was creating a new variable inside the loop (int n = x;) which kept resetting the value of x each time. That caused the loop to never actually reverse the number properly. After debugging, I corrected it by updating x directly instead of re-declaring n. Key Learning: Always check your loop variables carefully — one small mistake (like re-initializing inside the loop) can change the entire logic! #Java #Coding #ProblemSolving #LearningEveryday #LinkedInCodingJourney #Debugging #Programming

Today marks Day 28 of my Java learning journey — and today, I explored an interesting concept — finding how many times each element appears in a sorted array efficiently. Since the array is already sorted, similar elements are grouped together. This makes it possible to count frequencies in a single traversal, without using any additional data structures. Instead of checking every element repeatedly, we simply move through the array once, count consecutive duplicates, and print their frequency. This approach runs in O(n) time complexity and uses O(1) extra space, making it an elegant and optimized solution. Through this, I understood the importance of utilizing data properties — like sorted order — to simplify and speed up problem-solving. Such techniques are widely used in data analysis, compression algorithms, and frequency-based sorting. Learning this strengthened my understanding of loop control, conditional logic, and how efficient thinking transforms code performance. Every new concept is helping me refine my analytical approach and think like a true problem solver. 💡 #Java #Day28 #Coding #LearningJourney #DataStructures #Arrays #Programming #ProblemSolving #LogicBuilding #JavaLearning #Efficiency #Optimization 

💻 Exploring Java Programming: Strong Number Check 💡 Today, I practiced writing a Java program to check whether a number is a Strong Number — a number whose sum of the factorials of digits equals the number itself. For example: 👉 145 = 1! + 4! + 5! = 145 ✅ 👉 565 ≠ 5! + 6! + 5! ❌ Here’s a quick snippet from my code (shown below 👇): - Used a "while" loop for digit extraction - Calculated factorial using a nested "for" loop - Compared the final sum to the original number 🧠 Output: Enter a number to check: 145 145 is a strong number Always exciting to see how logic and math combine beautifully in programming! #Java #Coding #Programming #Learning #Engineering #StrongNumber #DeveloperJourney #CodeLogic

🎯 Day 7 of #365DaysofDSA Today I solved “Maximum Depth of Binary Tree” (LeetCode #104) 🌳 💡 Concepts used: • Recursion • Depth Calculation in Binary Trees ✨ Approach Summary: Used a recursive approach to find the longest path from the root node down to the farthest leaf node. For each node: 1️⃣ Recursively find the maximum depth of its left and right subtrees. 2️⃣ The current node’s depth = max(leftDepth, rightDepth) + 1. This elegant recursive solution divides the problem into smaller subproblems — calculating depth for subtrees and combining the results. 🚀 Key takeaway: Recursive thinking simplifies complex tree problems by leveraging the natural hierarchical structure of binary trees. 🌱 #Day7 #DSA #LeetCode #Java #BinaryTree #Recursion #ProblemSolving #CodingJourney #Programming #LearnByDoing #MaximumDepthOfBinaryTree

🚀 Day 10 of My Java Learning Journey – Exploring Method Overloading and Overriding! Today’s focus was on two important OOP principles in Java — Method Overloading and Method Overriding. 💻 🔹 Question 1: Created an AreaCalculator class demonstrating Method Overloading. ✔ Used the same method name calculateArea() with different parameter lists to find areas of Rectangle, Circle, and Triangle. ✔ Learned how overloading helps perform similar operations with varying input types. 🔹 Question 2: Demonstrated Method Overriding using Vehicle and Car classes. ✔ Used the @Override annotation to redefine the displayDetails() method in the subclass. ✔ Understood how runtime polymorphism allows the subclass to provide its own behavior. 🧠 Key Takeaways: ✨ Method Overloading → Same method name, different parameters (Compile-time Polymorphism). ✨ Method Overriding → Same method name, same parameters, different implementation (Runtime Polymorphism). ✨ Both improve code flexibility, readability, and reusability. 💬 Feeling more confident in mastering Polymorphism concepts step by step! 🌱 Cybernaut EdTech #60dayscodechallenges #TechTrio #CybernautEdtech #Java #OOP #LearningJourney #Programming #100DaysOfCode #Polymorphism #Overloading #Overriding #JavaDeveloper #CodeNewbie #Day10

📝 COMMENTS IN THE MIDDLE? TIME TO REFACTOR. If you need a comment to explain a chunk of logic inside a method, that logic probably deserves its own name. 👉 “Mid-method comments are a smell—extract a clearly named private method.” Name the intent, not the mechanics. Small, well-named methods read like a story and make bugs easier to spot. ✅ #CleanCode #Refactoring #Readability #SoftwareCraftsmanship #CodeQuality #DeveloperTips #Programming #Java