Optimizing Java Code for LeetCode Challenges

🚀 Day 14 – LeetCode 60 Days Challenge   Problem Solved: Search Insert Position Today I solved the classic Binary Search problem – Search Insert Position. 🔹 Problem: Given a sorted array and a target value, return the index if the target exists.   If not, return the index where it should be inserted to maintain sorted order. 🔹 Approach I Used: 1️⃣ Applied Binary Search (O(log n))   2️⃣ Used while(start <= end) template   3️⃣ Carefully adjusted boundaries:   - If nums[mid] < target → move start = mid + 1   - If nums[mid] > target → move end = mid - 1 4️⃣ If target is not found, return start as the correct insert position. 🔹 Key Insight: When the loop ends, start automatically points to the smallest index where the target can be placed without breaking sorted order. No extra condition needed. Binary Search naturally gives the insertion point. ⏱ Time Complexity: O(log n)   📦 Space Complexity: O(1) 🔹 Learning: - Never mix different binary search templates. - Choose one pattern and stick to it. - Boundary movement (mid - 1 vs mid) is VERY important. - Understanding loop termination is more important than memorizing code. Binary Search looks simple, but small boundary mistakes can break everything. Day 14 Done ✅   On to mastering Lower Bound & Upper Bound next 🚀 #LeetCode #BinarySearch #Java #DSA #InterviewPreparation #CodingJourney

Day 66 - LeetCode Journey Solved LeetCode 167: Two Sum II – Input Array Is Sorted (Medium) today — a great example of how knowing the properties of a sorted array can drastically simplify the solution. Since the array is already sorted in non-decreasing order, we can avoid extra data structures and use a two-pointer approach to find the pair efficiently. 💡 Core Idea: Start with two pointers: • left at the beginning • right at the end Then check the sum of the two numbers: If the sum is equal to the target → solution found If the sum is less than the target → move the left pointer forward If the sum is greater than the target → move the right pointer backward This gradually narrows down the search space until the correct pair is found. ⚡ Key Learning Points: • Leveraging sorted array properties • Efficient use of the two-pointer technique • Reducing time complexity to O(n) • Solving the problem with O(1) extra space Problems like this highlight how choosing the right technique can make solutions clean, fast, and elegant. ✅ Stronger understanding of two-pointer patterns ✅ Better optimization mindset ✅ Improved problem-solving intuition Every problem solved adds another useful pattern to the toolkit 🚀 #LeetCode #DSA #Java #TwoPointers #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperJourney #KeepCoding

Day 61 - LeetCode Journey Solved LeetCode 81: Search in Rotated Sorted Array II (Medium) today — a problem that combines binary search + edge case handling + duplicates. This isn’t just a normal binary search. Here, the array is rotated and may contain duplicates, which makes the decision logic more subtle. 💡 Core Idea: At every step, determine which half is sorted. Then decide whether the target lies in that sorted half. If duplicates block the decision, carefully shrink the search space. ⚡ Key Learning Points: • Applying binary search on a rotated array • Handling duplicate values that break clear ordering • Smart boundary adjustments (low++, high--) • Maintaining efficiency close to O(log n) in most cases The real challenge was not writing the code — It was thinking clearly about all possible scenarios. Problems like this strengthen pattern recognition and deepen understanding of search-based algorithms 💯 ✅ Stronger grip on modified binary search ✅ Better handling of tricky edge cases ✅ Improved logical decision-making Each variation of binary search builds sharper intuition. Still learning. Still improving. Still coding 🚀 #LeetCode #DSA #Java #BinarySearch #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

🚀 #60DaysOfLeetCode – Day 29 Today’s problem focused on finding all duplicates in an array where numbers are in the range 1 to n. The goal was to solve it efficiently without using extra space. 🔹 Approach Used: Cyclic Sort Since each number should ideally be placed at its correct index (value - 1), I used the Cyclic Sort technique to rearrange the elements. Steps: Traverse the array and place each number at its correct position. If the current number is not at its correct index and the target position contains a different value, swap them. Continue this process until every number is either in the correct position or a duplicate prevents correct placement. Finally, iterate through the array again and collect the numbers that are not at their correct index — these represent the duplicates. 🔹 Key Learning: When the input values are constrained to a specific range like 1 to n, techniques like Cyclic Sort can help achieve O(n) time complexity with O(1) extra space. This problem was a great reminder of how understanding array indexing patterns can lead to highly optimized solutions. Excited to continue the challenge and keep improving problem-solving skills! 💻🔥 #LeetCode #DSA #Java #CodingChallenge #ProblemSolving #LearningInPublic #60DaysOfCode

🚀 Day 12/100 — The Zero-Millisecond Pursuit Today’s Challenge: Micro-Optimizations & The "100% Club" ⚡ Yesterday was about the logic of grouping; today was about the JVM's hidden overhead. To hit that 0ms mark in Java, you have to treat the string like a raw buffer and minimize every method call. 💡 The Strategy: Beyond the API To shave off those final milliseconds and move from the 87th percentile to the top 1%, I focused on: String to Array: Instead of calling s.charAt(i) thousands of times (which includes repeated bounds checking), I converted the string to a char[] once. Direct array access is the "speedrunner's secret" in Java. Conditional Minimization: Every if-else is a potential branch misprediction for the CPU. I streamlined the state machine to use a single loop with minimal branching. Static Memory: Using primitive int variables exclusively. Avoiding any Integer objects or Collection wrappers that trigger the Garbage Collector (GC). 🔧 Deep Dive: The "0ms" Java Blueprint Avoid Method Calls in Loops: s.length() is fine, but charArray[i] beats s.charAt(i) in a tight loop every single time. The Ternary Advantage: In some JVM versions, a < b ? a : b can be faster than Math.min(a, b) because it's easier for the JIT compiler to inline. Primitive Power: When you eliminate object allocation, your memory graph flattens, and your runtime drops. ✨ Reflection Hitting 0ms isn't just about being "correct"—it's about understanding how your code translates into machine instructions. It’s a reminder that as a Software Engineer, you aren't just writing logic; you're managing hardware resources. 12 days down. The code is getting so lean it's practically invisible. 88 days to go. 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Optimization #CleanCode #Algorithms #JavaPerformance

𝗗𝗮𝘆 𝟱𝟲/𝟭𝟬𝟬 — 𝗕𝗮𝗰𝗸 𝘁𝗼 𝘁𝗵𝗲 𝗖𝗹𝗮𝘀𝘀𝗶𝗰𝘀 Day 56. Valid Parentheses. The problem everyone sees on Day 1 of learning stacks. Except this time? I actually get why it works. 𝗧𝗼𝗱𝗮𝘆'𝘀 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: ✅ #𝟮𝟬: Valid Parentheses (Easy) 𝗧𝗵𝗲 𝗣𝗿𝗼𝗯𝗹𝗲𝗺: Given a string of brackets: (), {}, []. Check if they're properly matched and nested. Examples: "()" → Valid "([)]" → Invalid (wrong order) "{[]}" → Valid (properly nested) 𝗧𝗵𝗲 𝗦𝗼𝗹𝘂𝘁𝗶𝗼𝗻: Stack. That's it. Push opening brackets. When you see a closing bracket, check if it matches the stack top. If yes, pop. If no, invalid. Empty stack at the end = valid. First time I saw this problem, I thought "why use a stack?" Now I see it—LIFO matches the nesting structure perfectly. 𝗪𝗵𝘆 𝗜𝘁 𝗠𝗮𝘁𝘁𝗲𝗿𝘀: This isn't just about parentheses. It's about recognizing when a problem needs LIFO behavior. Compilers use this. Code editors use this. Expression parsing uses this. Pattern recognition >> memorization. 𝗖𝗼𝗱𝗲: https://lnkd.in/gdCu84Ja 56 down. 44 to go. 𝗗𝗮𝘆 𝟱𝟲/𝟭𝟬𝟬 ✅ #100DaysOfCode #LeetCode #Stack #DataStructures #Algorithms #ProblemSolving #CodingInterview #Programming #Java #PatternRecognition

Day 70 - LeetCode Journey Solved LeetCode 88: Merge Sorted Array (Easy) today — a classic problem that focuses on array manipulation and the two-pointer technique. The challenge is to merge two sorted arrays into one sorted array without using extra space, by modifying nums1 in-place. 💡 Core Idea: Instead of merging from the beginning, we start from the end of the arrays. Why? Because nums1 already has extra space at the end to accommodate elements from nums2. We use three pointers: • i → last valid element in nums1 • j → last element in nums2 • k → last position of merged array At each step, we place the larger element at position k, ensuring the array remains sorted. ⚡ Key Learning Points: • Using the two-pointer technique from the end • Performing in-place array merging • Maintaining O(m + n) time complexity • Avoiding unnecessary extra space This problem is a great reminder that sometimes changing the direction of traversal makes the solution much simpler. ✅ Better understanding of array manipulation ✅ Stronger grasp of two-pointer techniques ✅ Improved problem-solving efficiency Small problems like this build strong fundamentals for bigger challenges 🚀 #LeetCode #DSA #Java #TwoPointers #Arrays #Algorithms #ProblemSolving #CodingJourney #Consistency #100DaysOfCode #InterviewPreparation #DeveloperGrowth #KeepCoding

🚀 Day 1/30: Kicking off my DSA Journey! Today’s focus: LeetCode 283 – Move Zeroes. 📝 The Challenge Given an integer array nums, the goal is to shift all the 0s to the end while keeping the non-zero elements strictly in their original order. ⚠️ The Catch: This must be done in-place (no extra memory allowed). 📌 Example Input: nums = [0, 1, 0, 3, 12] Output: [1, 3, 12, 0, 0] Explanation: The zeros are pushed to the back, while 1, 3, 12 stay in their exact original sequence. 💡 First Thoughts The brute-force way out? Just create a secondary array, dump the non-zero numbers in first, and pad the rest with zeros. But that directly violates the $O(1)$ space constraint. The real puzzle was figuring out how to achieve this by only modifying the original array. ⚙️ The Solution: Two-Pointer Technique To optimize the solution, I utilized the Two-Pointer method: Pointer i acts as the explorer, traversing the array. Pointer j acts as an anchor, tracking where the next non-zero element belongs. The Steps: Start j at index 0. Loop through the array with i. Whenever i finds a non-zero number, swap it with nums[j] and bump j up by 1. 🧠 Why It Works Because j only steps forward when a non-zero element is securely locked into place, the original relative order is perfectly preserved. As the non-zeroes move to the front, the zeros naturally get pushed to the back. Zero extra data structures, just a single pass! 📊 Complexity Time Complexity: $O(n)$ — We only traverse the array once. Space Complexity: $O(1)$ — Everything is modified completely in-place. 🔑 Takeaways The Two-Pointer strategy is an absolute lifesaver for tricky array manipulations. "In-place modification" and "preserving relative order" are incredibly common technical interview constraints. Small problems are the best way to test and solidify your core fundamentals. Consistency beats motivation! 💪 Let's build these skills one problem at a time. ##30DaysOfCode #DSA #LeetCode #Java #ProblemSolving #InterviewPreparation #CodingJourney

Two Pointers pattern — done. Here's what the last few days actually taught me. 🧵 Three Sum is Two Sum with a loop around it. First time I saw Three Sum — find all triplets that sum to zero — I thought it was a completely different problem. Turns out it isn't. Fix one element i. Now you just need two numbers from the rest of the array that sum to -arr[i]. That's Two Sum. Which is Two Pointers. Which you already know. Three Sum = loop + Two Sum. Four Sum = loop + Three Sum. The pattern scales. The core never changes. --- Dutch National Flag — the hardest-looking problem with the simplest explanation. Sort an array of only 0s, 1s, and 2s. In-place. No sort(). Single pass. The instructor explained it as a teacher sorting students — toppers (0) to the front, failures (2) to the back, average (1) stays in the middle. Three pointers: low, mid, high. Mid scans the unsorted zone and decides where each element belongs. O(n) time. O(1) space. One pass. The analogy made the algorithm stick instantly. --- The real output of this pattern: a decision framework. After every question, the same signals kept showing up: → Array or linked list problem → Sorted, or sorting helps → Merge / rearrange / remove duplicates in-place → Find a pair, triplet, or quadruplet Match two or more of these → Two Pointers is almost certainly the answer. Not intuition. A repeatable framework. Next: Sliding Window. Which, turns out, is just a specific type of Two Pointers. 💻 #DSA #TwoPointers #LeetCode #Java #CodingJourney #DSAPatterns #PadhoWithPratyush Pratyush Narain

#100DaysOfCode 🚀 👉Solved: LeetCode 75 – Sort Colors The goal was to sort an array containing only three values: 0 (Red), 1 (White), and 2 (Blue) At first glance this looks like a simple sorting problem. But the twist: ❌ No built-in sort ✔ One pass ✔ Constant space The solution uses the famous **Dutch National Flag Algorithm**. Instead of sorting normally, we maintain three pointers: • low → for 0s • mid → current element • high → for 2s Rules: • If nums[mid] == 0 → swap with low • If nums[mid] == 1 → move mid forward • If nums[mid] == 2 → swap with high This allows sorting the array in a single pass. 📌 Key Points: ✔ In-place sorting ✔ One pass algorithm ✔ Constant space usage ✔ Classic three-pointer technique ⏱ Time Complexity: O(n)   📦 Space Complexity: O(1) Problems like this show how powerful pointer techniques can be. Day 15✅ #DSA #Java #LeetCode #Algorithms #ProblemSolving #100DaysOfCode #CodingJourney #LearnInPublic