"Dynamic Tracking for Maximum Product Subarray"

🔹 Day 54: Sign of the Product of an Array (LeetCode #1822) 📌 Problem Statement: You're given an integer array nums. Consider the product of all elements in the array. Based on this product: Return 1 if it is positive Return -1 if it is negative Return 0 if it is zero Instead of actually multiplying (which can overflow), you're asked to determine only the sign of the product. --- ✅ My Approach: I avoided calculating the full product because it can grow very large. Instead, I focused on the sign only. Here’s the logic I followed: Initialize a variable to track the sign. Iterate through each number: If any number is 0, the result is immediately 0, since the product becomes zero. If the number is negative, flip the sign. After processing all numbers, return the tracked sign. This avoids overflow and keeps the solution efficient. --- 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) --- ⚡ Submission Stats: Runtime: 0 ms (Beats 100%) 🚀 Memory: 45.32 MB (Beats 6.29%) --- 💡 Reflection: A simple yet elegant problem that highlights how sometimes we don't need the full value — only the effect of the operations. Great reminder to think efficiently! #LeetCode #Java #Math #Optimized #100DaysOfCode #Day54

Day 18 — Frequency Boost Mode ON! Problem: 3346. Maximum Frequency of an Element After Performing Operations I Difficulty: Medium Today’s problem was all about maximizing the frequency of an element in an array — but with a twist 🔄. You can tweak elements up or down by up to k, but only for a limited number of operations. The challenge? Figuring out how to best use those operations to make one number appear the most times possible. It’s a mix of prefix sums, counting frequency, and a bit of greedy optimization — perfect for sharpening problem-solving intuition. Takeaway: Sometimes, optimization isn’t about making everything perfect — it’s about finding where a few smart changes make the biggest difference. #Day18 #LeetCode #Java #ProblemSolving #100DaysOfCode #CodingChallenge #LeetCodeMedium #DataStructures #Algorithms

🚀 Day 6 of Improving Problem-Solving Today, I solved LeetCode 27: Remove Element, which at first looked like an easy problem but required careful thinking to arrive at an optimal in-place solution. 🧩 Problem Statement: Given an array nums and a value val, remove all occurrences of val in-place and return the number of elements not equal to val. ⚙️ Approach Used: Two Pointers Technique To solve this efficiently, I applied the two-pointer approach, which helps modify arrays in place without extra space. 🔹 Logic Explained: Use two pointers, i and j. j scans each element, while i tracks the position where the next valid (non-val) element should go. If nums[j] != val, assign nums[i] = nums[j] and increment both i and j. This way, all valid elements are shifted to the front, and duplicates or unwanted values are removed efficiently. 💡 This problem helped me strengthen my understanding of in-place algorithms and how two-pointer logic can simplify seemingly tricky problems. Each day, I’m realizing that solving problems isn’t just about getting the right answer — it’s about improving clarity, logic, and consistency. #Day6 #ProblemSolving #DSA #TwoPointers #LeetCode #Java #CodingJourney

📌 Day 161 of Coding - Minimum Number of Increments on Subarrays to Form a Target Array (LeetCode - Hard) 🎯 Goal: Find the minimum number of operations required to form a target array starting from an array of zeros, where each operation increments all elements of a chosen subarray by 1. 💡Approach & Debugging: Used a difference-based greedy approach to count only the necessary increments. Steps: Initialize sum with the first element, representing the increments needed for the first number. Traverse the array: Whenever target[i] > target[i - 1], it means additional increments are needed. Add the difference (target[i] - target[i - 1]) to sum. The total sum gives the minimum number of operations required. ✔️ Time Complexity: O(N) - single pass through the array. ✔️ Space Complexity: O(1) - constant extra space. 🧠Key Takeaways: A classic prefix difference trick, focus on the increase, not the absolute value. Greedy approaches often emerge naturally in array transformation problems. #Day161 #LeetCode #GreedyAlgorithm #ArrayProblems #Java #ProblemSolving #DSA #Algorithms #CodingChallenge #InterviewPrep #100DaysOfCode #SoftwareEngineering #CodeNewbie #ProgrammersLife

🚀 Day 130 of #150DaysOfCode Today’s challenge — LeetCode 2011: Final Value of Variable After Performing Operations — was a quick but satisfying one! 💡 🔍 Problem Overview: Given an array of strings representing operations on a variable x, we need to determine its final value after all operations are performed. Each operation is either "++X", "X++", "--X", or "X--". Increment operations increase the value by 1, while decrement operations decrease it by 1. 💻 Approach: Iterate through the array and check whether each operation contains "++". If yes → increment x Otherwise → decrement x ✅ Time Complexity: O(n) ✅ Space Complexity: O(1) This problem reinforced the importance of string traversal, condition checking, and writing clean, concise code for simple logic problems. 🧩 Key Concepts: #Java #String #Array #Implementation #LogicBuilding #ProblemSolving #DataStructures #Algorithms #CodingChallenge #LeetCode #100DaysOfCode #150DaysOfCode #DailyCoding #Consistency

✅ Day 51 of LeetCode Medium/Hard Edition Today’s challenge was about generating numbers whose prime factors are limited to 2, 3, and 5 — the classic Ugly Number II problem! 💫 📦 Problem: An ugly number is a positive integer whose prime factors are restricted to 2, 3, and 5. Given an integer n, return the nth ugly number. 🔗 Problem Link: https://lnkd.in/gS9EKbbd ✅ My Submission: https://lnkd.in/gnTe_zvY 💡 Thought Process: To generate the sequence in ascending order, we can use a Min-Heap + HashSet approach: Start from 1, the first ugly number. Repeatedly multiply it by {2, 3, 5} to generate new candidates. Maintain a min-heap to always pick the next smallest number. Use a set to avoid duplicates. After popping n elements, the last popped value is our nth ugly number. ⏱ Complexity: Time: O(n log n) Space: O(n) 🔥 Key Takeaway: Combining heaps and hashing efficiently maintains order and uniqueness in sequence generation. A great demonstration of how priority queues can systematically build ordered numeric sequences — step by step! #LeetCodeMediumHardEdition #100DaysChallenge #Heap #HashSet #ProblemSolving #DataStructures #CodingJourney #Java #LeetCode

🚀 Day 40 of My #LeetCode Challenge 🚀 📘 Problem: Number of Sub-arrays of Size K and Average Greater than or Equal to Threshold (LeetCode #1343) 💡 Approach: Implemented the Sliding Window technique to efficiently calculate the sum of each subarray of size k. First, compute the sum of the initial k elements. Then, slide the window forward — subtract the element leaving and add the new one entering. Check if the average of the current window meets or exceeds the given threshold. This method optimizes the time complexity to O(n) by avoiding repetitive summation. ⏱️ Concepts Used: Sliding Window | Arrays | Optimization | Time Complexity 🔥 Consistency and logic go hand in hand — every day adds a new layer to my problem-solving skills! #Day40 #LeetCode #100DaysOfCode #CodingChallenge #Java #DSA #ProblemSolving #CodingJourney #TechLearning #CodeEveryday #SoftwareEngineering #ProgrammerLife #CodingCommunity #Developer #JavaProgramming #LearnToCode #TechGoals #CodeNewbie #Algorithm #DataStructures #CodingPractice

🔥 Day 33/100 of #100DaysOfCode - Alternating Positive & Negative! Today's Problem: Rearrange Array Elements by Sign Task: Given an array with equal number of positive and negative integers, rearrange them in alternating positive/negative order (starting with positive). Solution: Used a two-pointer approach with separate indices for positive and negative positions! Created a temp array and placed positives at even indices (0, 2, 4...) and negatives at odd indices (1, 3, 5...). Key Insights: Since the array has equal positives and negatives, we can pre-determine positions O(n) time complexity with O(n) space for the temp array Clean and intuitive - no complex swapping needed Smart Pointer Management: Positive pointer moves by +2 each time Negative pointer moves by +2 each time Single pass through the original array Elegant solution for maintaining relative order while achieving the required alternation! ⚡ #100DaysOfCode #LeetCode #Java #Algorithms #Arrays #TwoPointers #CodingInterview

💪 Day 8 of 100 Days of LeetCode 📘 Problem: #238. Product of Array Except Self 💻 Difficulty: Medium 🔍 Concept: Given an array nums, return an array where each element is the product of all numbers except itself — without using division and in O(n) time. ⚙️ Approach Used: Computed prefix (left) and suffix (right) products. Combined them to get the final result for each index. Optimized without using extra space for readability in future iterations. 🧠 Key Learnings: Strengthened understanding of prefix-suffix product pattern. Practiced space optimization strategies and handling edge cases like zeros. 💻 Code (Java): class Solution { public int[] productExceptSelf(int[] nums) { int n = nums.length; int[] ans = new int[n]; int left = 1, right = 1; for (int i = 0; i < n; i++) { ans[i] = left; left *= nums[i]; } for (int i = n - 1; i >= 0; i--) { ans[i] *= right; right *= nums[i]; } return ans; } } 🔥 Reflection: This problem was a great reminder that division isn’t always the solution — sometimes, breaking a problem into smaller cumulative parts gives a cleaner and more efficient result. #100DaysOfLeetCode #Day8 #CodingChallenge #Java #LeetCode #DSA #ProblemSolving #LearningJourney

🌟 Day 84 of My #100DaysOfCode Challenge 🧩 Problem: LeetCode 108 – Convert Sorted Array to Binary Search Tree 💭 Understanding the Problem Given a sorted array, we need to convert it into a height-balanced Binary Search Tree (BST) — meaning the difference in height between the left and right subtrees of every node should not exceed one. 📘 Example: Input: nums = [-10, -3, 0, 5, 9] Output: [0, -3, 9, -10, null, 5] The middle element (0) becomes the root, left half forms the left subtree, and the right half forms the right subtree. 🧠 Key Idea Pick the middle element as the root for balance. Recursively repeat the same for left and right halves. This approach ensures that the BST remains balanced. ⚙️ Complexity Analysis Time Complexity: O(n) — each element is processed once. Space Complexity: O(log n) — recursion stack in a balanced tree. ✨ Takeaway This problem beautifully combines recursion and binary tree logic, showcasing how dividing the array strategically helps maintain balance in a BST. 💬 "Balanced structures are key to efficiency — both in code and in life!" 😄 #Day84 #LeetCode #Java #DSA #BinaryTree #CodingChallenge #100DaysOfCode #ProblemSolving