Determining the sign of the product of an array in O(n) time

🚀 Day 63 – Tackling Fluctuating Products with Dynamic Tracking! 🧩 Problem: 152. Maximum Product Subarray The task is to find the contiguous subarray that produces the maximum product — a classic challenge because negative numbers can flip the result unpredictably. 🧠 Approach To handle the unpredictable effect of negatives, I used a dual-tracking dynamic approach: 👉 I maintained maxProduct and minProduct at each step. 👉 A negative number can turn a large positive into a large negative — or turn a large negative into a new maximum. 👉 So whenever I encountered a negative value, I swapped the current max and min to keep their roles correct. Then: maxProduct = max(current number, current × maxProduct) minProduct = min(current number, current × minProduct) The global result tracks the highest maxProduct seen so far. 🔗 Problem Link: https://lnkd.in/gFS48h5c 🔗 GitHub Link: https://lnkd.in/gCe-A-Ev 💡 Reflection This problem reinforced how crucial it is to understand behavior under change. A single negative value can invert the entire outcome so tracking both extremes becomes essential. It’s a good reminder that elegant solutions often come from recognizing patterns, not just applying formulas. Thinking dynamically and adapting per element turned a chaotic problem into a predictable one. #LeetCode #Arrays #DynamicProgramming #TwoPointers #Java #Day63 #CodingJourney #100DaysChallenge #ProblemSolving #LearningEveryday #CleanCode

🌟 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

🚀 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 49: Increasing Triplet Subsequence (LeetCode #334) 📌 Problem Statement: Given an integer array nums, return true if there exists a triplet (i, j, k) such that i < j < k and nums[i] < nums[j] < nums[k]. Otherwise, return false. ✅ My Approach: I used two variables — a and b — to keep track of the smallest and second smallest elements while iterating through the array. If the current number is smaller than or equal to a, update a. Else if it’s smaller than or equal to b, update b. Otherwise, if a number is greater than both, we found a valid increasing triplet — return true. This approach efficiently finds the triplet in one pass without extra space. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) ⚡ Submission Stats: Runtime: 2 ms (Beats 96.23%) Memory: 133.92 MB (Beats 53.76%) 💡 Reflection: This problem showed how simple tracking variables can replace nested loops, achieving a linear-time solution for a seemingly complex condition. 🔥 #LeetCode #Java #Greedy #Optimization #100DaysOfCode #Day49

🔹 Day 52: Self Dividing Numbers (LeetCode #728) 📌 Problem Statement: A self-dividing number is a number that is divisible by every digit it contains. For example, 128 is self-dividing because 128 % 1 == 0, 128 % 2 == 0, and 128 % 8 == 0. Given two integers left and right, return a list of all self-dividing numbers in that range (inclusive). ✅ My Approach: I iterated through each number in the range [left, right] and checked if it was self-dividing using a helper function. For each number: Extract each digit using modulo and division. If any digit is zero or the number isn’t divisible by that digit, it’s not self-dividing. Otherwise, include it in the result list. 📊 Complexity: Time Complexity: O(n × d), where d is the number of digits. Space Complexity: O(1) (excluding the output list). ⚡ Submission Stats: Runtime: 2 ms (Beats 73.19%) Memory: 42.48 MB (Beats 10.09%) 💡 Reflection: This problem strengthened my skills in digit manipulation and modular arithmetic. It’s a great exercise for mastering number decomposition and iteration logic. ✨ #LeetCode #Java #Math #Loops #100DaysOfCode #Day52

💪 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 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 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 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 53 of My LeetCode Journey 🚀 📌 Problem: Peak Index in a Mountain Array 👉 Given a mountain array (strictly increasing then strictly decreasing), find the index of the peak element. 🧠 Approach Used: Binary Search Instead of scanning the whole array, I applied binary search to find the point where the value stops increasing and starts decreasing. 🔍 Idea: If arr[mid] < arr[mid + 1], we are in the increasing part → move right. Else, we are in the decreasing part → move left. 💡 Why Binary Search here? We take advantage of the mountain shape to reduce search space efficiently. ⏱ Time Complexity: O(log n) 📌 Space Complexity: O(1) 🔥 Key takeaway: Binary Search is not just for sorted arrays — it works for any problem where you can eliminate half of the search space intelligently. On to the next one! 💪 #100DaysOfCode #LeetCode #Day53 #Java #BinarySearch #ProblemSolving #CodingJourney