Minimum Operations to Make a Uni-Value Grid: LeetCode Solution

🚀 Day 85 – DSA Journey | Balanced Binary Tree Continuing my daily DSA practice, today I tackled a problem that combines tree traversal with optimization. 📌 Problem Practiced: Balanced Binary Tree (LeetCode 110) 🔍 Problem Idea: Determine whether a binary tree is height-balanced — meaning the difference between heights of left and right subtrees is at most 1 for every node. 💡 Key Insight: Instead of calculating height separately for each node (which leads to O(n²)), we can compute height and check balance in a single traversal using a smart approach. 📌 Approach Used: • Use recursion to calculate height of each subtree • If any subtree is unbalanced, return -1 immediately • Check if |left height - right height| > 1 → not balanced • Otherwise, return height = 1 + max(left, right) • Final result depends on whether we ever get -1 📌 Concepts Strengthened: • Tree traversal • Recursion optimization • Early stopping technique • Efficient problem solving ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Optimizing recursive solutions by combining multiple checks into one traversal can significantly improve performance. On to Day 86! 🚀 #Day85 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 87 – DSA Journey | Binary Tree Preorder Traversal Continuing my daily DSA practice, today I explored another important tree traversal technique using an iterative approach. 📌 Problem Practiced: Binary Tree Preorder Traversal (LeetCode 144) 🔍 Problem Idea: Traverse a binary tree in preorder — Root → Left → Right — and return the sequence of node values. 💡 Key Insight: Using a stack, we can simulate recursion and control the traversal order. By pushing the right child before the left, we ensure the left subtree is processed first. 📌 Approach Used: • Use a stack and start with the root node • Pop node, process (add to result) • Push right child first, then left child • Repeat until stack is empty 📌 Concepts Strengthened: • Tree traversal (Preorder) • Stack usage • Iterative vs recursive approach • Order control in traversal ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Understanding traversal order and stack behavior makes it easier to convert recursive tree problems into iterative ones. On to Day 88! 🚀 #Day87 #DSAJourney #LeetCode #BinaryTree #Stack #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 84 – DSA Journey | Maximum Depth of Binary Tree Continuing my daily DSA practice, today I focused on understanding tree depth and recursive problem solving. 📌 Problem Practiced: Maximum Depth of Binary Tree (LeetCode 104) 🔍 Problem Idea: Find the maximum depth (or height) of a binary tree — the number of nodes along the longest path from the root to a leaf node. 💡 Key Insight: The depth of a tree depends on its subtrees. At every node, we can recursively calculate the depth of left and right subtrees and take the maximum. 📌 Approach Used: • If the node is null → depth is 0 • Recursively calculate depth of left subtree • Recursively calculate depth of right subtree • Return 1 + max(left, right) 📌 Concepts Strengthened: • Binary tree traversal • Recursion • Divide and conquer approach • Tree height calculation ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Breaking problems into smaller subproblems using recursion makes complex tree problems much easier to handle. On to Day 85! 🚀 #Day84 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 Day 76 – DSA Journey | Remove Adjacent Duplicates using Stack Continuing my daily DSA practice, today I solved a problem that highlights how stacks can simplify string manipulation. 📌 Problem Practiced: Remove All Adjacent Duplicates in String (LeetCode 1047) 🔍 Problem Idea: Given a string, repeatedly remove adjacent duplicate characters until no more duplicates remain. The final result is guaranteed to be unique. 💡 Key Insight: A stack helps efficiently track characters and remove duplicates instantly when the current character matches the top of the stack. 📌 Approach Used: • Traverse the string from left to right • Push characters onto the stack • If the current character matches the top → pop (remove duplicate) • Continue this process until the string is fully processed • Build the final string from the stack 📌 Concepts Strengthened: • Stack data structure • String manipulation • Pattern removal problems • Efficient traversal techniques ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Stacks are powerful for handling adjacent comparisons and undo-type operations in strings. On to Day 77! 🚀 #Day76 #DSAJourney #LeetCode #Stack #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 LeetCode Challenge 32/50 💡 Approach: Factorial Number System (Math + Greedy) Generating all n! permutations and picking the kᵗʰ one would be O(n! × n) — way too slow! Instead, we use the Factorial Number System to directly compute the kᵗʰ permutation digit by digit in O(n²)! 🔍 Key Insight: → Precompute factorials: fact[i] = i! → Convert k to 0-based index (k--) → For each position, there are (n-1)! permutations starting with each digit → index = k / fact[i-1] tells which digit to pick next → Remove used digit, update k = k % fact[i-1], repeat! 📈 Complexity: ❌ Generate all permutations → O(n! × n) Time ✅ Factorial Number System → O(n²) Time, O(n) Space Sometimes the best algorithm isn’t about searching — it’s about computing the answer directly using pure math! 🧑🔬 #LeetCode #DSA #Math #Greedy #Java #ADA #PBL2 #LeetCodeChallenge #Day32of50 #CodingJourney #ComputerEngineering #AlgorithmDesign #PermutationSequence

🚀 Day 109 DSA Problem Solving 📌 Problem Solved: Maximum Distance Between a Pair of Values 💡 Level: Medium 🧠 Problem Idea Given two non-increasing arrays, find the maximum distance (j - i) such that: i ≤ j nums1[i] ≤ nums2[j] 🔍 Key Learning Today reinforced a powerful pattern: 👉 When arrays are sorted, always think about Two Pointers before brute force. ⚙️ Approach Used Used Two Pointers (i, j) If condition satisfies → expand j to maximize distance Else → move i to find a smaller value ⏱ Time Complexity O(n + m) ✅ (No nested loops, super efficient) 💭 Real Journey Behind the Solution Initially, I thought about checking all pairs (brute force), but that would lead to TLE. Then I noticed both arrays are non-increasing, which unlocked the two-pointer optimization. This is a reminder that: 👉 Observing constraints carefully can completely change the approach. 📈 Concepts Practiced Two Pointers Greedy Thinking Array Traversal Optimization 🔥 Takeaway Not every problem needs complex logic—sometimes the smartest solution is just about moving pointers wisely. #Day109 #DSAJourney #LeetCode #Coding #Java #ProblemSolving

🚀 Day 75 — Slow & Fast Pointer (Happy Number Detection) Extending the slow‑fast pointer pattern beyond linked lists — today I applied it to a mathematical problem involving cycles. 📌 Problem Solved:  - LeetCode 202 – Happy Number 🧠 Key Learnings: 1️⃣ The Problem in a Nutshell  A number is happy if repeatedly replacing it with the sum of squares of its digits eventually reaches 1. If it enters a cycle that doesn’t include 1, it’s unhappy. 2️⃣ Why Slow‑Fast Pointer Works   - The sequence of numbers (n → sum of squares of digits → ...) will eventually either reach 1 or enter a cycle.   - This is exactly like detecting a cycle in a linked list — except the “next” is defined mathematically.   - Slow moves one step: `slow = sq(slow)`   - Fast moves two steps: `fast = sq(sq(fast))`   - If they meet at a value other than 1 → cycle exists → unhappy number.   - If fast reaches 1 → happy number. 3️⃣ The sq() Helper Computes sum of squares of digits. Clean and reusable. 4️⃣ Edge Cases - n = 1 → returns true immediately (loop condition `fast != 1` fails, returns true).   - Numbers like 2, 3, 4 eventually cycle (4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4). 💡 Takeaway:  The slow‑fast pointer pattern isn’t just for linked lists — it’s a general cycle detection tool that works for any sequence with a deterministic “next” step. Recognizing this abstraction is what makes a great problem solver. No guilt about past breaks — just one problem at a time, one pattern at a time. #DSA #SlowFastPointer #HappyNumber #CycleDetection #LeetCode #CodingJourney #Revision #Java #ProblemSolving #Consistency #GrowthMindset #TechCommunity #LearningInPublic

Day 24 of #100DaysOfCode I stared at this problem for 40 minutes trying every possible target value. Then one insight — borrowed from basic statistics — made it click instantly. 🧩 The Problem: Minimum Operations to Make a Uni-Value Grid (LeetCode 2033 — Medium) Given a 2D grid and a fixed step value x, transform every element to the same value using the minimum number of add/subtract operations. My first instinct? Try every possible target. Loop through everything. Classic overthinking. 😅 💡 The Key Insight — Why the Median? The median minimizes the sum of absolute differences. This is a well-known statistics fact — and it maps perfectly to this problem. Instead of brute-forcing every target, the strategy is simple: → Flatten the 2D grid into a 1D array → Sort it → Pick the middle element (median) as the target → Count total operations using the absolute difference divided by x No guessing. No unnecessary loops. Just math doing the heavy lifting. ⚠️ The Constraint Check Nobody Talks About Before applying any operations — check if all elements share the same remainder when divided by x. If they don't, it's mathematically impossible to make the grid uni-value. Return -1 immediately and save the computation entirely. This "fail fast" mindset is just as important as the algorithm itself. 📈 Complexity Breakdown → Flatten + Sort → O(n log n) → Single pass to count operations → O(n) → Space → O(n) for the flattened array Simple, clean, and efficient. 🧠 What This Problem Reinforced ✅ Greedy thinking with median optimization ✅ Handle impossible cases before computation — fail fast ✅ Transform 2D problems into simpler 1D forms ✅ Let math do the heavy lifting before writing a single loop The best solutions often come from asking: "What does math already know about this?" On to the next challenge 💪 👇 What's a problem where a simple insight saved you from overcomplicating things? Drop it in the comments — would love to learn from your experience! #100DaysOfCode #LeetCode #DSA #Java #ProblemSolving #CodingJourney #SoftwareEngineering #Programming

🚀 Day 55 – 100 Days Coding Challenge 📌 Problem: Convert Number to English Words ⚙️ Approach • Break the number into chunks of 3 digits (hundreds) using modulo and division • Process each chunk separately and map it with its corresponding scale (Thousand, Million, Billion) • Use helper arrays for: – Numbers below 20 – Tens (20, 30, …, 90) – Scale values (Thousand, Million, etc.) • For each chunk: – Convert hundreds place – Handle tens and units • Concatenate all parts in the correct order to form the final string 🧠 Logic Used • Mathematical decomposition (splitting number into base-1000 chunks) • String construction using mapping arrays • Handling edge cases like zero and trailing spaces • Modular and reusable helper function for clean conversion 🔗 GitHub: https://lnkd.in/g_3x55n8 ✅ Day 55 Completed #100DaysOfCode #Java #DSA #ProblemSolving #Algorithms #DataStructures #LeetCode #CodingPractice #Strings #MathLogic

Day 38 of My DSA Journey Today I solved LeetCode 152 – Maximum Product Subarray on LeetCode. 📌 Problem Given an integer array nums, find the contiguous subarray that has the largest product, and return that product. Example: Input: [2,3,-2,4] Output: 6 → subarray [2,3] 🧠 Approach – Dynamic Programming (Tracking Max & Min) This problem is tricky because of negative numbers. Key Idea: • At each index, we maintain: maxProduct → maximum product ending at current index minProduct → minimum product ending at current index 👉 Why min? Because a negative number can turn a small (negative) product into a large positive one. Steps I followed: • Initialize maxProduct, minProduct, and ans with the first element • Traverse the array from left to right • If the current number is negative → swap max and min • Update: maxProduct = max(current, current × maxProduct) minProduct = min(current, current × minProduct) • Update the final answer using maxProduct ⏱ Time Complexity: O(n) — Single pass through the array 📦 Space Complexity: O(1) — No extra space used 💡 Key Learnings ✔ Handling negative numbers in product problems ✔ Using dynamic programming with state tracking ✔ Understanding why tracking both max & min is important This is one of those problems that looks simple but tests deep understanding of edge cases 🚀 Consistency continues — leveling up every day 💪 #100DaysOfCode #DSA #DynamicProgramming #Arrays #LeetCode #Java #ProblemSolving #CodingJourney #DeveloperJourney #Programming #SoftwareEngineering