Efficiently Add One to a Number Array in Java

Day7 - LeetCode Journey Solved LeetCode 912: Sort an Array in Java ✅ This problem was a good exercise in going back to basics and understanding how sorting actually works under the hood. Instead of relying on built-in sort functions, the focus here was on writing the logic manually and thinking about time and space trade-offs. I implemented a simple comparison-based approach, paying close attention to how elements shift and settle into their correct positions. While the performance may not be the fastest possible, the process helped me strengthen my understanding of sorting fundamentals and algorithm behavior on larger inputs. Key learnings from this problem: • How element shifting impacts performance • Why algorithm choice matters for large datasets • The importance of clarity over shortcuts ✅ Accepted solution with all test cases passed ✅ Reinforced core concepts that often show up in interviews Consistent DSA practice is teaching me that improvement is not always about speed, but about understanding what’s happening at every step. Slowly building better problem-solving habits 💪 #LeetCode #DSA #Java #Algorithms #Sorting #DataStructures #ProblemSolving #CodingJourney #InterviewPreparation #Consistency

Day4 - LeetCode Journey Solved LeetCode 33: Search in Rotated Sorted Array using a clean and efficient approach in Java 🚀 Worked on searching an element in a rotated sorted array while respecting performance constraints. This problem helped strengthen concepts around array traversal, conditions, and optimizing search logic in Java. Key ideas used: • Understanding rotated sorted array properties • Applying correct search logic with conditions • Handling edge cases carefully ✅ Accepted with excellent runtime performance ✅ Optimized and interview-ready solution Consistently practicing DSA to improve logical thinking and problem-solving skills. Moving forward, one problem at a time 💪 #LeetCode #DSA #DataStructures #Algorithms #Java #ProblemSolving #CodingPractice #InterviewPreparation #Consistency

Day 8/25 – LeetCode Challenge 🚀 🔸Problem: Find First and Last Position of Element in Sorted Array 🔸Difficulty: Medium 🔸Topic: Array, Searching 🔸Language: Java Approach 🛠️: ▫️Iterated through the array once to locate the target value. ▫️Tracked the first occurrence when the target is found initially. ▫️Continuously updated the last occurrence index for subsequent matches. ▫️Returned default values when the target does not exist in the array. ▫️This approach keeps the solution simple and easy to understand. Key Learnings 📚: 🔹Handling default values for edge cases is important 🔹Tracking first and last positions in a single pass 🔹Understanding problem constraints before optimizing 🔹Clean logic improves readability and debugging #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

Day 2/25 – LeetCode Challenge 🚀 🔸Problem : Merge Sorted Array 🔸Difficulty : Easy 🔸Topic : Arrays, Three Pointers 🔸Language : Java Approach 🛠️ : ▫️Used a three-pointer technique starting from the end of both arrays. ▫️Compared elements from nums1 and nums2 and placed the larger one at the correct position. ▫️By filling nums1 from the back, avoided overwriting existing values. ▫️Continued until all elements from nums2 were merged. ▫️This ensures an in-place solution with optimal time complexity. Key Learnings 📚: 🔹Efficient use of two pointers for sorted arrays 🔹Importance of reverse traversal in in-place problems 🔹How to avoid extra space while merging arrays 🔹Reinforced understanding of array manipulation #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

🚀 Day 48 of My Daily Coding Challenge 🚀 Today I implemented In-Place Merge Sort using Recursion — focusing on sorting the array without creating new subarrays. 📌 What I worked on: • Dividing the array using start, mid, and end indices • Recursively sorting left and right halves • Merging both halves back within the same array using a temporary buffer • Careful index handling to avoid extra space overhead 💡 Key Learning: Understanding how indices flow in recursion is crucial for writing efficient, in-place algorithms. This approach strengthened my grasp of divide-and-conquer logic and memory handling. 🔗 Solution (Java):[https://lnkd.in/dBM-nBCC] #100DaysOfCode #Day48 #Java #DSA #MergeSort #InPlaceAlgorithm #Recursion #ProblemSolving #CodingJourney #LearnInPublic

Day6 - LeetCode Journey Solved LeetCode 75: Sort Colors in Java ✅ This problem looks simple on the surface, but it really pushes you to think about how to sort data efficiently when certain constraints are in place. Since using the library sort was not allowed, the focus shifted to understanding the problem deeply and choosing the right approach instead of relying on shortcuts. I worked through the logic step by step, using a frequency-based approach to rearrange the elements in-place while keeping the solution clean and easy to follow. Handling constraints properly and writing clear code mattered more here than just getting the output right. Key learnings: ---------------------------- • Thinking beyond default sorting methods • Working within strict constraints • Writing simple, readable logic for efficiency ✅ Accepted with strong runtime performance ✅ Reinforced core array and problem-solving fundamentals Consistent DSA practice is helping me build confidence and improve how I approach new problems. One problem at a time 💪 #LeetCode #DSA #Java #Arrays #Algorithms #ProblemSolving #CodingJourney #InterviewPreparation #Consistency

Day 5/25 – LeetCode Challenge 🚀 🔸Problem: Single Number 🔸Difficulty: Easy 🔸Topic: Arrays, Brute Force 🔸Language: Java Approach  🛠️: ▫️Iterate through each element in the array and count its occurrences. ▫️Use a nested loop to compare the current element with all others. ▫️Track the count and identify the number that appears only once. ▫️Handle the edge case where the array has only one element. ▫️Return the element whose frequency is exactly one. Key Learnings  📚: 🔹Reinforced understanding of nested loops and frequency counting 🔹Importance of handling edge cases explicitly 🔹Clear trade-off between simplicity and time complexity 🔹Strengthened fundamentals of array traversal #25DaysOfLeetCode #LeetCode #DSA #Java #ProblemSolving #Coding #Consistency

Day 4 – LeetCode 345 | Reverse Vowels of a String | Two Pointers Description: Continuing Day 4 of my LeetCode practice with LeetCode 345: Reverse Vowels of a String. Used the Two Pointer approach to scan from both ends, swap only vowels, and leave all other characters untouched. This avoids extra space and keeps the solution efficient. Time Complexity: O(n) Space Complexity: O(1) Key learnings: • Identifying when two pointers beat brute force • Clean character swapping logic • Handling edge cases without using unnecessary libraries Discipline beats talent. More problems coming. Tags: #LeetCode #Day4 #TwoPointers #Strings #ProblemSolving #Java #DSA #CodingJourney