Merging Sorted Arrays with Two Pointers in Java

💡 Day 78 of #100DaysOfCode 💡 🔹 Problem: Find Closest Number to Zero – LeetCode ✨ Approach: Traversed through the array while keeping track of the number closest to zero using absolute difference comparison. Handled ties by preferring the positive number — because even in code, positivity wins 😉 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — single pass through the array 💾 Space Complexity: O(1) — no extra space used ✅ Runtime: 3 ms (Beats 44.80%) ✅ Memory: 46.87 MB 🔑 Key Insight: Even the smallest differences matter — especially when you’re finding what’s closest to zero! ⚡ #LeetCode #100DaysOfCode #DSA #ProblemSolving #CodingChallenge #JavaProgramming #AlgorithmDesign #CodeJourney #StayPositive

🔢 Day 69 of #100DaysOfCode 🔢 🔹 Problem: Maximum Count of Positive and Negative Integers – LeetCode ✨ Approach: A simple yet powerful one-pass solution! Iterated through the array, counting positives and negatives separately — and returned whichever count was greater. Clean, direct, and efficient. ⚡ 📊 Complexity Analysis: Time Complexity: O(n) — single traversal of the array Space Complexity: O(1) — no extra data structures used ✅ Runtime: 1 ms (Beats 12.27%) ✅ Memory: 46.89 MB 🔑 Key Insight: Sometimes, simplicity wins — clarity in logic often outperforms complex tricks. Counting right leads to coding right! 💡 #LeetCode #100DaysOfCode #ProblemSolving #DSA #Array #AlgorithmDesign #LogicBuilding #CodeJourney #ProgrammingChallenge #CodingDaily #Efficiency

🚀 Day 81 of 100 Days of Leetcode Challenge - Problem 3354: Make Array Elements Equal to Zero 🔍 Problem Overview: In today's challenge, we are tasked with finding the number of valid selections in an integer array nums. The goal is to select a starting position, curr, where nums[curr] = 0, and choose a direction (left or right) to move, while following specific conditions. 🌟 Solution Walkthrough: We start by selecting a valid initial position and direction. The movement continues, updating the position and reversing direction based on the values at the current position. We track the possible valid selections that lead to all elements becoming zero. 🔧 Dry Run Example: For the input nums = [1, 0, 2, 0, 3]: We test multiple initial positions and directions. The possible valid selections are identified, leading to the final result. 💡 Brute Force Approach: We iterate through all possible initial positions and directions, but this results in suboptimal time complexity. ⚡ Optimal Approach: Using efficient iteration and tracking mechanisms, we can achieve a more optimal solution that reduces the overall time complexity. ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) ✅ Key Learnings: Handling edge cases is crucial. A good understanding of direction reversal and boundary checks is essential. 🔑 Edge Cases: Arrays with all zeros. Handling large arrays efficiently. 🔝 Hashtags & Keywords: #100DaysOfLeetcode #LeetcodeChallenge #CodingJourney #ProblemSolving #AlgorithmDesign #TechieLife #LeetcodeSolutions #LeetcodeProblems #TimeComplexity #SpaceComplexity #CodingCommunity #TechCareer #CodingIsLife #BruteForceVsOptimal #CompetitiveProgramming

Day 5 of 30 Solving Leetcode ✅ Problem : Count the Number of Good Partitions- O(n*logn) Approach : If we have Duplicate element of a particular integer . We have to take all duplicate element in a one subarray and we can find this using a map , left most & right most index of a element . Example : arr = [1,2,4,3,2,3] We have to take elements of subarray arr[1,4] and subarray arr[3,5] at once . And arr[1,4] and arr[3,5] overlap , so we have to take arr[1,5] at once Now we can easily find ans = 1<<len , where len represent length of subarray that we have to take at once . Here len is 2 - arr[0,0] & arr[1,5] #leetcode #dsa #problemsolving #leetcodechallenge

I recently tackled LeetCode 2654 – Minimum Number of Operations to Make All Array Elements Equal to 1. Most solutions simulate every operation. The approach that worked for me came from stepping back and thinking mathematically: 1️⃣ If there’s already a 1 in the array, it can be spread to all other elements efficiently. 2️⃣ If no 1 exists, find the shortest subarray whose GCD is 1 – creating a 1 from that subarray is the minimal first step. 3️⃣ Once a 1 exists, the rest follows in a straightforward way. It’s a reminder that sometimes understanding the structure of a problem beats brute-force coding. And here’s a little validation: ✅ Runtime: 1ms, beats 100% of submissions ✅ Memory: 56.1MB, beats 100% of submissions For anyone doing coding challenges or preparing for interviews, focus on insights like these – they often save more time than writing extra lines of code. #ProblemSolving #Algorithms #CodingMindset #LeetCode #SoftwareEngineering

🧩 LeetCode Challenge – Day 70 ✅ Dove into one of the more challenging divide-and-conquer problems — counting reverse pairs in an array. 🔗 LeetCode 493 – Reverse Pairs This problem takes the concept of inversions a step further, combining sorting logic with counting conditions. The key insight lies in leveraging a modified merge sort, where you track valid pairs while merging. It’s a great reminder of how algorithmic tweaks can unlock major efficiency gains. 💡 Key Takeaways: • Divide and conquer remains one of the most powerful paradigms in algorithm design. • Optimized counting teaches how to merge logic and efficiency seamlessly. • Understanding problem patterns often matters more than brute implementation. #Day70 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #DivideAndConquer #MergeSort #BinarySearch

🚀 Day 110 of #LeetCode Challenge! Problem: Duplicate Zeros 💡 My Approach: The task is to duplicate every zero in the array in-place, shifting the remaining elements to the right. First, count the total number of zeros to determine the “virtual” extended array size. Then, use two pointers — one (i) for the original array and another (j) for the extended index. Traverse backward: Copy each element from i to j. If it’s a zero, write an additional zero (when within bounds). This avoids overwriting elements and keeps the solution in O(1) extra space. ✨ Example: Input: [1,0,2,3,0,4,5,0] Output: [1,0,0,2,3,0,0,4] ⏱ Time Complexity: O(N) — single pass from the end 💾 Space Complexity: O(1) — done in-place without extra memory 👨💻 GitHub Link: https://lnkd.in/gCuFGw-c #LeetCode #Array #InPlaceAlgorithm #TwoPointers #ProblemSolving #DuplicateZeros #Day110 #DSA #CodingChallenge #C++

🚀 Day 8 of My LeetCode Journey 🔢 Problem #167: Two Sum II - Input Array Is Sorted Today’s challenge was all about leveraging array properties efficiently. The task: given a sorted array, find two numbers that add up to a specific target and return their 1-based indices. 💡 Approach: Two Pointers Since the array is already sorted, we can avoid brute-force and use a two-pointer technique for O(n) time complexity. 🧠 Intuition Start with two pointers: ➡️ left at the beginning and right at the end. If the sum of the two numbers is greater than the target → move right left. If the sum is smaller → move left right. Continue until we find the exact pair. ⏱️ Time Complexity: O(n) 💾 Space Complexity: O(1)

🧩 LeetCode Challenge – Day 69 ✅ Explored another elegant twist in the world of recursion — generating unique subsets with duplicates in play. 🔗 LeetCode 90 – Subsets II This problem extends the classic subsets question by introducing duplicates, which means managing uniqueness through careful control. It’s a precise exercise in sorting, skipping, and structuring recursion to avoid redundancy — a true test of clean logical flow. 💡 Key Takeaways: • Sorting simplifies complexity — order enables control. • Handling duplicates trains precision and discipline in recursive solutions. • Elegant logic > brute force — small refinements can make solutions scalable and readable. #Day69 #LeetCodeChallenge #100DaysOfCode #DSA #CodingJourney #ProblemSolving #Backtracking #Recursion #Subsets

🎯 Day 81 of #100DaysOfCode 🎯 🔹 Problem: Reverse Only Letters – LeetCode ✨ Approach: Used a two-pointer strategy to reverse only the alphabetic characters while keeping all non-letter characters in their original positions. By moving pointers inward and swapping only when both characters are letters, the solution stays efficient and elegant! 🔄✨ 📊 Complexity Analysis: ⏱ Time Complexity: O(n) — each character visited at most once 💾 Space Complexity: O(n) — due to character array construction ✅ Runtime: 0 ms (Beats 100% 🚀) ✅ Memory: 42.96 MB 🔑 Key Insight: Sometimes, all you need is smart pointer movement — not everything needs to be reversed, only the right pieces. #LeetCode #100DaysOfCode #DSA #TwoPointers #StringManipulation #ProblemSolving #CleanCode #AlgorithmDesign #CodingChallenge