Symmetric Tree Problem Solved with Recursive Approach

🚀 Day 25/60 — LeetCode Discipline Problem Solved: Search Insert Position (Revision) Difficulty: Easy Today’s practice focused on revisiting one of the most fundamental algorithms in computer science — Binary Search. The task was to efficiently determine the position of a target element in a sorted array, or identify the correct index where it should be inserted while maintaining order. This problem reinforces how dividing the search space in half at each step leads to highly efficient solutions with logarithmic time complexity. 💡 Focus Areas: • Strengthened binary search fundamentals • Practiced boundary condition handling • Improved mid-index calculation logic • Reinforced logarithmic-time problem solving • Focused on writing clean and precise code ⚡ Performance Highlight: Achieved 0 ms runtime (100% performance) on submission. Revisiting foundational algorithms like binary search continues to sharpen problem-solving precision and efficiency. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #BinarySearch #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers #Java

🚀 Day 26/60 — LeetCode Discipline Problem Solved: Remove Element (Revision) Difficulty: Easy Today’s practice focused on revisiting a fundamental array problem involving in-place modification. The task was to remove all occurrences of a given value without using extra space, while efficiently maintaining the remaining elements. The solution leverages a simple yet powerful approach of iterating through the array and overwriting unwanted elements. Problems like this reinforce the importance of space optimization and clean in-place operations, which are often crucial in real-world scenarios. 💡 Focus Areas: • Strengthened in-place array manipulation • Practiced efficient element filtering • Reinforced two-pointer style iteration • Improved understanding of space optimization • Focused on writing concise and readable code ⚡ Performance Highlight: Achieved 0 ms runtime (100% performance) on submission. Simple problems, when practiced with discipline, continue to sharpen the core of problem-solving ability. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #Arrays #TwoPointers #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers #Java

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

Day 61 on LeetCode — Contiguous Array (Find Max Length of Equal 0s and 1s) ⚖️✅ This problem is a classic application of prefix sum + hashmap technique. 🔹 Idea Behind the Solution The key trick is to convert the problem into a prefix sum problem: • Treat 0 as -1 and 1 as +1 • Maintain a running sum (sum) • If the same sum appears again at two indices, it means the subarray between them has equal number of 0s and 1s 🔹 How the HashMap Helps • Store the first occurrence of each prefix sum • If a prefix sum repeats at index i and was previously seen at index j, then:   i - j gives a balanced subarray length 🔹 Initialization Trick • seen{{0, -1}} ensures that subarrays starting from index 0 are correctly handled ⚡ Complexity: • Time: O(n) • Space: O(n) 💡 Key Takeaways: • Converting binary problems into prefix sum transformations simplifies logic • Hashmaps are powerful for tracking previous states of cumulative sums • Recognizing patterns where equal values → zero sum subarray is very useful 🔥 This is a very important pattern for array + hashmap + prefix sum problems! #LeetCode #DSA #Algorithms #DataStructures #PrefixSum #HashMap #Arrays #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney

🚀 Day 535 of #750DaysOfCode 🚀 ✅ Solved: Count Submatrices with Top-Left Element and Sum ≤ k (LeetCode 3070) Today’s problem was a great example of using 2D Prefix Sum to optimize matrix queries. Instead of checking every possible submatrix, we can observe that the question only allows submatrices that include the top-left element (0,0). This means every valid submatrix is just a prefix rectangle, so we can compute the sum efficiently using prefix sums. 💡 Key Learning: Used 2D Prefix Sum technique Reduced brute force complexity to O(m × n) Learned how to handle matrix range sum problems efficiently 📌 Approach: Build prefix sum for each cell Check if sum from (0,0) to (i,j) ≤ k Count valid submatrices This problem improved my understanding of: ✔️ Prefix Sum ✔️ Matrix DP patterns ✔️ Optimization from brute force to efficient solution Consistency continues 🔥 On to Day 536 tomorrow. #leetcode #java #datastructures #algorithms #codingchallenge #prefixsum #matrix #programming #softwareengineering #750daysofcode

Day 20 of my #30DayCodeChallenge: Efficiency through Pruning! Today's challenge was Word Search II-a complex puzzle that tests how you manage massive search spaces. The Logic: 1. Trie Integration: I stored the dictionary in a Trie to check prefixes in O(1) time. 2. DFS & Backtracking: Explored the grid cell by cell, but with a twist... 3. Intelligent Pruning: If a path doesn't match a Trie prefix, the search stops immediately. This turns an exponential problem into something much more manageable. Coding isn't just about finding the answer; it's about finding it before your timer runs out! #Java #DataStructures #Backtracking #Trie #Algorithms #CleanCode #150DaysOfCode

🚀  Day 29 LeetCode Problem Solved: Longest Consecutive Sequence (128) Today I solved an interesting Data Structures & Algorithms problem on LeetCode. 💻 🔹 Problem: Given an unsorted array of integers, find the length of the longest consecutive elements sequence in O(n) time complexity. 🔹 Example: Input: [100, 4, 200, 1, 3, 2] Output: 4 👉 The longest consecutive sequence is [1,2,3,4]. 🔹 Approach: Instead of sorting the array (which takes O(n log n)), I used a HashSet to achieve O(n) time complexity. ✔ Store all numbers in a HashSet ✔ Identify the start of a sequence (num - 1 not present in the set) ✔ Expand the sequence forward (num + 1, num + 2...) ✔ Track the maximum length 🔹 Complexity: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(n) 💡 Key Learning: Using HashSet efficiently can help optimize problems that involve searching and sequence detection. Excited to keep learning and improving problem-solving skills! 🚀 #leetcode #coding #java #datastructures #algorithms #softwaredeveloper #programming #codingjourney

🚀 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 27 of my #30DayCodeChallenge: The Efficiency of Binary Exponentiation! The Problem: Pow(x, n). Implementing the power function to calculate x". While it sounds simple, the challenge lies in handling large exponents (up to 231 - 1) and negative powers without hitting time limits or overflow. The Logic: This problem is a classic example of Divide and Conquer optimized through Binary Exponentiation (also known as Exponentiation by Squaring): 1. Bitwise Breakdown: Instead of multiplying x by itself n times (O(n)), we decompose n into powers of 2. For example, x13 is x8. x4. x¹. This brings our complexity down to O(log n). 2. The Iterative Jump: In every iteration of the loop, we square the current base (x = x x). If the current bit of n is 1 (checked via n & 1), we multiply our result by the current base. 3. Handling the Edge Cases: * Negative Exponents: If n is negative, we calculate xI" and then take the reciprocal (1/result). Overflow: We use a long for n during calculation to avoid overflow when converting -2, 147, 483, 648 to a positive value. The Calculation: By halving the power at each step, we transform a task that could take 2 billion operations into one that takes just 31. One step closer to mastery. Onward to Day 28! #Java #Algorithms #DataStructures #BinaryExponentiation #ProblemSolving #150DaysOfCode #SoftwareEngineer

🚀 Day 42 of My LeetCode Journey Today’s problem: Regular Expression Matching This wasn’t just another coding problem — it forced me to think in terms of state transitions and decision trees, not brute force. 🔍 Key Learning: - Pure recursion is not enough → leads to exponential time - Introduced Dynamic Programming (Top-Down with Memoization) - Learned how to break the problem into: - Matching current characters - Handling "*" (zero or more occurrences) 🧠 Core Insight: Instead of trying all possibilities blindly, cache results of subproblems → avoids recomputation. ⚡ Result: - Runtime: 1 ms (Beats 99.99%) - Efficient DP solution with optimal pruning 💡 Takeaway: Hard problems aren’t about syntax — they’re about modeling the problem correctly. #Day42 #LeetCode #DataStructures #DynamicProgramming #Java #CodingJourney