Container With Most Water LeetCode Solution

🚀Day 4/100 – LeetCode Journey Today’s problem: 3Sum Closest🔥 Approach (Sorting + Two Pointer)💡 👉 Workflow (step-by-step): 1. Sort the array → helps in using two-pointer efficiently 2. Fix one element (nums[k]) 3. Use two pointers: i = k + 1 (left) j = n - 1 (right) 4. Calculate: sum = nums[k] + nums[i] + nums[j] 5. Compare: If this sum is closer to target than previous → update closestSum ✅ 6. Move pointers: If sum < target → i++ (increase sum) If sum > target → j-- (decrease sum) Repeat until all possibilities are checked. Key Idea: We are not finding exact match, we are finding the closest possible sum to target ⚡ Time Complexity: O(n²) → outer loop + two pointer 🧠 Space Complexity: O(1) → no extra space used Thanks to RAVI KUMAR Sir for guidance! Getting better every day 🚀 #100DaysOfCode #LeetCode #DSA #Java

Day 77/100 Completed ✅ 🚀 Solved LeetCode – Search a 2D Matrix II (Java) ⚡ Implemented an efficient approach by starting from the top-right corner of the matrix and eliminating rows or columns based on comparison with the target. This reduces the search space at every step, achieving O(m + n) time complexity. 🧠 Key Learnings: • Smart traversal in a sorted 2D matrix • Eliminating search space using row & column properties • Moving left (col--) when value is greater • Moving down (row++) when value is smaller • Better than brute-force (O(m × n)) approach 💯 This problem improved my understanding of matrix traversal strategies and how to optimize searching using sorted properties. 🔗 Profile: https://lnkd.in/gaJmKdrA #leetcode #datastructures #algorithms #java #matrix #problemSolving #optimization #arrays #100DaysOfCode 🚀

🚀 Day 58 of #100DaysOfCode Solved 165. Compare Version Numbers on LeetCode 🔗 🧠 Key Insight: Version strings are split by "." into multiple revisions. We compare each revision numerically (not lexicographically). Example: "1.01" = "1.1" (leading zeros don’t matter) ⚙️ Approach (Split + Compare): 1️⃣ Split both versions using "." 🔹 version1 → s1[] 🔹 version2 → s2[] 2️⃣ Traverse till max length of both arrays 3️⃣ For each index i: 🔹 num1 = i < s1.length ? parseInt(s1[i]) : 0 🔹 num2 = i < s2.length ? parseInt(s2[i]) : 0 4️⃣ Compare: 🔹 if num1 < num2 → return -1 🔹 if num1 > num2 → return 1 5️⃣ If all equal → return 0 ⏱️ Time Complexity: O(n + m) 📦 Space Complexity: O(n + m) (for split arrays) #100DaysOfCode #LeetCode #DSA #Strings #TwoPointers #Java #InterviewPrep #CodingJourney

🚀 Day 71/100 – LeetCode Challenge Solved: Remove Duplicates from Sorted List II (Medium) Today’s problem was a great test of Linked List manipulation and handling edge cases efficiently. 🔍 Key Insight: Since the list is sorted, duplicates appear consecutively. Instead of keeping one copy, the challenge is to remove all nodes with duplicate values, leaving only distinct elements. 💡 Approach: Used a dummy node to handle edge cases Applied two-pointer technique (prev & current) Skipped entire duplicate sequences in one pass ⚡ Result: Runtime: 0 ms (Beats 100%) Space Complexity: O(1) 🎯 Key Learning: Handling duplicates in linked lists requires careful pointer updates — especially when the head itself is part of duplicates. Consistency is key 🔥 #Day71 #LeetCode #100DaysOfCode #Java #DataStructures #LinkedList #ProblemSolving #CodingJourney

🚀 𝐃𝐚𝐲 91/100 – 𝐌𝐚𝐱 𝐂𝐨𝐧𝐬𝐞𝐜𝐮𝐭𝐢𝐯𝐞 𝐎𝐧𝐞𝐬  🔍 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠: Keeping track of a running count helps efficiently solve problems involving continuous sequences. 💡 𝐂𝐨𝐫𝐞 𝐈𝐝𝐞𝐚: Traverse the array Count consecutive 1s Reset count when 0 appears Track maximum count  𝐖𝐡𝐲 𝐢𝐭 𝐰𝐨𝐫𝐤𝐬? We only care about continuous 1s, so resetting on 0 ensures we start counting a new sequence. ⚡ 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Initialize count = 0 and max = 0 Loop through array: If 1 → increment count Else → reset count Update max at each step ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(1) #Day91 #100DaysOfCode #Java #DSA #LeetCode #Arrays #CodingJourney

Some of the hardest problems become manageable once you recognize a repeating pattern. 🚀 Day 105/365 — DSA Challenge Solved: Subarrays with K Different Integers Problem idea: We need to count subarrays that contain exactly k distinct integers. Efficient approach: Use the powerful trick: subarrays with exactly k distinct = subarrays with ≤ k distinct − subarrays with ≤ (k − 1) distinct Steps: 1. Use a sliding window with a hashmap to track frequency of elements 2. Expand window by moving right pointer 3. If distinct count exceeds k, shrink window from the left 4. Count valid subarrays ending at each index 5. Subtract results to get exact count This pattern converts a hard problem into a manageable one. ⏱ Time: O(n) 📦 Space: O(n) Day 105/365 complete. 💻 260 days to go. Code: https://lnkd.in/dad5sZfu #DSA #Java #SlidingWindow #HashMap #LeetCode #LearningInPublic

𝐃𝐚𝐲 𝟔𝟑 – 𝐃𝐒𝐀 𝐉𝐨𝐮𝐫𝐧𝐞𝐲 | 𝐀𝐫𝐫𝐚𝐲𝐬 🚀 Today’s problem focused on rotating an array to the right by k steps efficiently. 𝐏𝐫𝐨𝐛𝐥𝐞𝐦 𝐒𝐨𝐥𝐯𝐞𝐝 • Rotate Array 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡 – 𝐑𝐞𝐯𝐞𝐫𝐬𝐚𝐥 𝐓𝐞𝐜𝐡𝐧𝐢𝐪𝐮𝐞 • First normalized k using k % n • Reversed the entire array • Reversed the first k elements • Reversed the remaining elements This results in the desired rotation. 𝐊𝐞𝐲 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠𝐬 • Reversal technique is a powerful in-place trick • Breaking a problem into steps simplifies logic • Modulo helps handle large values of k • In-place operations reduce space complexity 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲 • Time: O(n) • Space: O(1) 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲 Sometimes the best solution is not shifting elements — but rearranging them smartly. 63 days consistent 🚀 On to Day 64. #DSA #Arrays #TwoPointers #LeetCode #Java #ProblemSolving #DailyCoding #LearningInPublic #SoftwareDeveloper

🚀Day 2/100 – LeetCode Journey Today’s problem: Two Sum II (Sorted Array) 💡Approach (Two Pointer Method) Since the array is sorted, I used two pointers: One at the start (i) One at the end (j) 👉Logic: If nums[i] + nums[j] == target → return answer ✅ If sum is greater → move j-- If sum is smaller → move i++ In this problem, we return 1-based index → so answer is (i + 1, j + 1) ⚡Time Complexity: O(n) → single pass using two pointers 🧠 Space Complexity: O(1) → no extra space used 🙌 Thanks to RAVI KUMAR Sir for guidance! . . #100DaysOfCode #LeetCode #DSA #Java

Day 65/75 — Count Pairs Whose Sum is Less than Target Today’s problem was a clean application of sorting + two pointers. Approach: • Sort the array • Use two pointers (i at start, j at end) • If nums[i] + nums[j] < target → all pairs between i and j are valid • Add (j - i) to count and move i forward • Otherwise, move j backward Key idea: if(nums.get(i) + nums.get(j) < target)  count += (j - i); Time Complexity: O(n log n) (sorting) Space Complexity: O(1) This pattern shows up a lot in pair-based problems — very important to master. 65/75 🔥 #Day65 #DSA #TwoPointers #Sorting #Java #LeetCode

Taking the Two-Pointer technique to LeetCode! Today's challenge: Remove Duplicates from a Sorted Array. After practicing the Two-Pointer pattern for reversing arrays and swapping 0s and 1s, I applied it to a classic LeetCode problem. The challenge? Remove duplicates from an array in-place with O(1) extra memory. Because the array is already sorted, all duplicates are grouped together. • The Slow Pointer (The Writer): Keeps track of where the next unique element should be placed. • The Fast Pointer (The Reader): Scans ahead through the array to find new, unique numbers. • The Logic: If the Reader finds a duplicate, it just skips it. But the moment the Reader finds a new number, the Writer records it at the front of the array and steps forward. #DSA #Java #LeetCode #RemoveDuplicate