60-Day LeetCode Challenge Day 44 Product of Array Except Self

🚀 Day 13 of LeetCode Problem Solving Solved today’s problem — LeetCode #560: Subarray Sum Equals K 💻🔥 ✅ Approach: Prefix Sum + HashMap ⚡ Time Complexity: O(n) 📊 Space Complexity: O(n) The task was to find the total number of subarrays whose sum equals k. 👉 Instead of checking all subarrays (O(n²)), I used an optimized approach with prefix sum + HashMap. 💡 Key Idea: If currentSum - k already exists in the map, it means a subarray with sum = k is found. 👉 Core Logic: Maintain running sum Check if (sum - k) exists in map Add its frequency to count Store current sum in map 💡 Key Learning: Prefix Sum + HashMap is a powerful pattern for subarray problems — must know for interviews 🚀 Consistency is the key — growing stronger every day 🔥 #Day13 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 66 of #LeetCode Challenge ✅ Problem Solved: Divide a String Into Groups of Size K 💡 What I learned today: • Learned how to break a string into fixed-size groups • Understood how to handle incomplete groups using a fill character • Practiced building strings step-by-step using loops • Improved clarity on index handling and conditions 🧠 Approach: • Traverse the string one character at a time • Build a group until it reaches size k • Store the group and reset • If the last group is smaller, fill remaining positions with the given character 📊 Key Takeaway: Handling edge cases (like incomplete groups) is very important in problem solving 🔥 Consistency is the key — improving step by step every day! #Day66 #LeetCode #CodingJourney #DSA #Java #ProblemSolving #Consistency

🚀 Day 79 of #LeetCode Journey Solved: Maximum Product Subarray 💡 At first, I implemented a brute-force approach (O(n²)) by checking all possible subarrays. It worked, but I knew it wasn’t efficient enough for interviews. Then I learned the optimized approach (O(n)) — and this problem became really interesting! 🔑 Key Insight: Because of negative numbers, the maximum product can suddenly become minimum and vice versa. 👉 So instead of tracking just the maximum, we track: Maximum product so far Minimum product so far This helps handle cases where: Negative × Negative = Positive And gives us the correct maximum product efficiently 📈 What I Learned: Not all problems are solved by simple iteration Tracking extra state can drastically improve performance Always think about edge cases like negatives & zeros 💻 Language: Java ⏱ Optimized Complexity: O(n) Consistency is the key 🔥 #Day79 #DSA #Java #CodingJourney #LeetCode #ProblemSolving

Solved: Linked List Cycle (LeetCode 141) Today’s problem was all about detecting cycles in a linked list using the classic Floyd’s Cycle Detection Algorithm (Tortoise & Hare) 🐢🐇 💡 Key Takeaways: Using two pointers (slow & fast) makes cycle detection efficient No extra space needed → O(1) space complexity Time complexity stays optimal → O(n) Simple logic, but powerful concept for interviews Consistency is starting to pay off. Small steps every day = big progress over time. #Day25 #DSA #LeetCode #CodingJourney #Java #100DaysOfCode #ProblemSolving #TechGrowth

✅ LeetCode Top Interview 150 – Day 112 Today I solved Find K Pairs with Smallest Sums Key Idea : Use Min Heap (Priority Queue) to track smallest sum pairs Start with pairing first element of nums2 with elements of nums1 Always pick the smallest sum pair from heap Push next possible pair for that index Avoid generating all pairs to keep it efficient Time complexity : O(k log n) #DSA #Java #Leetcode #Day1121

DSA Practice Update Today I solved: #78 – Subsets Learned the backtracking approach to generate all possible subsets (power set). Understood how to explore both choices at each step: including or excluding an element, and how to use recursion with backtracking to build all combinations. Key Learnings: • Introduction to backtracking technique • Recursion with decision making (pick / not pick) • Building combinations step by step This problem helped me understand the fundamentals of backtracking, which is an important concept for many interview problems. Continuing to stay consistent and strengthen core concepts. #DSA #LeetCode #CodingJourney #Java #SoftwareDevelopment #PlacementPreparation

✅ LeetCode Top Interview 150 – Day 108 Today I solved Pow(x, n) Key Idea : Use Binary Exponentiation (Fast Power) Divide the problem into halves using n / 2 If n is even → xⁿ = (x^(n/2))² If n is odd → multiply one extra x Handle negative power by converting to reciprocal This approach reduces time complexity to O(log n) #DSA #Java #Leetcode #Day108

Solved one of the most interesting problems : Subarray Sum Equals K 💡 Key Takeaway: Instead of checking every subarray, tracking prefix sums helps directly identify valid subarrays in an optimized way. 👉 Key Insight: If (prefixSum - k) has already appeared, it means we found a subarray with sum = k. 📊 Time Complexity: O(n) 📦 Space Complexity: O(n) 🔍 What made it interesting? Understanding how previously seen sums help us avoid rework and directly count valid subarrays. Every day I realize: Consistency and clarity of concepts matter more than just solving problems. 💪 #DSA #Java #LeetCode #CodingJourney #BackendDeveloper #SoftwareEngineering

🚀 Day 33 of my #100DaysOfCode Journey Today, I solved the LeetCode problem: Product of Array Except Self Problem Insight: Given an array, return a new array where each element is the product of all other elements except itself, without using division. Approach: • Used prefix (left) product to store multiplication of previous elements • Traversed from right to calculate suffix product • Combined both to get the final answer • Handled cases with zeros without using division Time Complexity: • O(n) Space Complexity: • O(1) (excluding output array) Key Learnings: • Prefix and suffix technique is very useful • Avoiding division helps handle edge cases • Practice improves problem-solving skills Takeaway: Simple patterns like prefix and suffix can solve complex problems easily with practice. #DSA #Java #LeetCode #100DaysOfCode #CodingJourney #ProblemSolving

📅 Date: April 27, 2026 Day 6 of my LeetCode Journey 🚀 ✅ Problem Solved: 15. 3Sum 🧠 Approach & Smart Solution: This classic medium-level problem is a great test of optimizing loops! A brute-force O(n³) approach would easily hit a Time Limit Exceeded (TLE). Instead, I optimized it to O(n²) using the Sorting + Two-Pointer technique. • Pseudo-code: First, sort the given array. Iterate through the array with an index 'i'. Skip duplicate elements to avoid duplicate triplets. Set two pointers: 'j' right after 'i', and 'k' at the end of the array. While 'j' is less than 'k': Calculate the sum of elements at i, j, and k. If the sum is 0, we found a valid triplet! Add it to the result list, and smoothly skip any duplicate values for both 'j' and 'k'. If the sum is less than 0, increment 'j' to increase the sum. If the sum is greater than 0, decrement 'k' to decrease the sum. By sorting first, we can systematically eliminate duplicate triplets and efficiently navigate towards the target sum without redundant checks! ⏱️ Time Complexity: O(n²) (Sorting takes O(n log n), and the two-pointer search takes O(n²)) 📦 Space Complexity: O(1) (Auxiliary space, excluding the space required for the output list) 📊 Progress Update: • Streak: 6 Days 🔥 • Difficulty: Medium • Pattern: Two Pointers / Sorting 🔗 LeetCode Profile: https://lnkd.in/gBcDQwtb (@Hari312004) Mastering the two-pointer technique on sorted arrays is a massive level-up for optimizing complex algorithms! 💡 #LeetCode #DSA #TwoPointers #Java #CodingJourney #ProblemSolving #InterviewPrep #Consistency #BackendDevelopment