Solved LeetCode Day 28: Find Minimum in Rotated Sorted Array

🔥 LeetCode Day 27 Challenge Problem Attempted: Search in Rotated Sorted Array II 💡 Approach & Progress: Today, I explored how to search for a target element in a rotated sorted array that contains duplicates. This version is trickier than the original because duplicates can make it hard to determine which half of the array is sorted. I learned that the key is to handle edge cases carefully — especially when the elements at low, mid, and high are equal. In such cases, it becomes impossible to decide which side is sorted, so the best approach is to shrink the search space by moving both pointers inward. After managing duplicates, I applied the standard binary search logic by identifying which half of the array is sorted and checking if the target lies within that range. 🧠 Key Learnings: Understood how duplicates affect binary search in rotated arrays. Learned to identify and manage ambiguous cases where sorting order is unclear. Improved logical reasoning for range-based conditions in binary search. Strengthened confidence in solving complex search variations efficiently. #LeetCode #Day27 #BinarySearch #DSA #ProblemSolving #CodingChallenge #Java #Algorithm #100DaysOfCode #LeetCodeJourney #CodeEveryday #TechLearning #ProgrammerLife

Day 25 of #LeetCode Challenge 🔹 Problem: 3354. Make Array Elements Equal to Zero 🔹 Difficulty: Easy 🔹 Topic: Array | Simulation | Prefix Sum Today’s problem was a fun logic-based simulation involving movement and balance between left and right sums. The goal was to find how many starting positions (and directions) could lead to every element becoming zero. The trick here is realizing that you don’t actually need to simulate every move — just track prefix sums and compare left and right totals. If they’re equal (or differ by 1), it’s a valid starting point. A neat mix of math and logic! #LeetCode #100DaysOfCode #Day25 #Java #CodingChallenge #ProblemSolving #LearnToCode #LeetCodeDaily #ProgrammingJourney #DSA #Algorithms

🌳 Day 62 of 100 Days of LeetCode 🌳 Today’s challenge: LeetCode 226 – Invert Binary Tree 🔄 🧩 Problem Summary: Given the root of a binary tree, invert it — meaning swap the left and right children of every node. Essentially, you’re mirroring the entire tree! 🌲✨ 💡 Key Takeaways: 🔹 Strengthened understanding of tree traversal using recursion. 🔹 Learned how a simple DFS (Depth-First Search) can elegantly solve structural transformations. 🔹 Practiced reasoning about symmetry and recursion base cases. 🧠 Approach: 1️⃣ If the tree is empty, return null. 2️⃣ Recursively invert the left and right subtrees. 3️⃣ Swap the left and right children of the current node. 4️⃣ Return the root once the tree is fully inverted. 🚀 A great example of how recursion simplifies complex problems into smaller, intuitive steps! #LeetCode #100DaysOfCode #Java #DSA #BinaryTree #CodingJourney #Recursion #ProblemSolving

✅ LeetCode Day 45 — Problem #162: Find Peak Element 🚀 Approach: I applied the Binary Search technique to locate a peak element efficiently. Initialize two pointers l and r. Compute the middle index m. If nums[m] < nums[m + 1], it means the peak lies on the right side → move l = m + 1. Otherwise, the peak lies on the left or at m → move r = m. Continue until l == r, which gives the index of the peak element. ⏱️ Time Complexity: O(log n) 💾 Space Complexity: O(1) 💡 Learning: Binary search can be applied beyond just sorted arrays — it’s a powerful pattern for problems with a “direction” property! #LeetCode #Day45 #DSA #BinarySearch #ProblemSolving #Java #100DaysOfCode #LearningEveryday #CodingChallenge

📅 Day 78 of #100DaysOfLeetCode Problem: N-Queens II (LeetCode #52) Approach: This problem is similar to the classic N-Queens, but instead of returning the board configurations, we only need to count the total number of valid arrangements. Use Backtracking to explore every possible way of placing queens on the board. For each row, place a queen in a safe column (no conflicts in column or diagonals). When a valid configuration is found (all rows filled), increment the count. Complexity: ⏱️ Time: O(N!) — exploring all valid queen placements 💾 Space: O(N²) — for storing board state and recursion stack 🔗 Problem Link: https://lnkd.in/dKUTwJcT 🔗 Solution Link: https://lnkd.in/daFhdj8v #LeetCode #100DaysOfCode #Backtracking #NQueens #Recursion #Java #Algorithms #ProblemSolving #CodingChallenge #DSA #DailyCoding #CodeNewbie #BuildInPublic #LearnToCode #EfficientCode #StudyWithMe

#Day5 of #100DaysOfCode Challenge! 🔥 Today’s focus is on strengthening array fundamentals through two challenging problems: Missing Number and First Repeating Element. Problem 1: LeetCode 268 – Missing Number Objective: Identify the missing number in an array containing n distinct numbers ranging from 0 to n. Approach: Utilized the sum formula, n*(n+1)/2, to calculate the expected sum. By subtracting the actual sum of the array elements, the missing number was readily identified. Time Complexity: O(n) | Space Complexity: O(1) This solution is concise, elegant, and exemplifies a clean approach to solving interview problems. Problem 2: First Repeating Element (GFG) Objective: Determine the first repeating element with the smallest index (1-based). Approach: Traversed the array from right to left, utilizing a HashSet to store elements. Whenever a number was encountered that was already present in the HashSet, the index was updated to ensure the smallest possible value. Time Complexity: O(n) | Space Complexity: O(n) Key Takeaway: Recognizing when a mathematical shortcut, such as the sum formula, is applicable versus when a data structure, like a HashSet, is necessary, cultivates strong problem-solving intuition. Balancing simplicity and optimization is crucial for achieving significant growth in problem-solving skills. Thank you Rajesh Gupta for your assistance in guiding me through this process. #100DaysOfCode #LeetCode #DSA #ProblemSolving #Arrays #CodingChallenge #LearningInPublic #Java #Programming

🌳 Day 60 of 100: Maximum Depth of Binary Tree 🌳 Today’s challenge was LeetCode 104 – Maximum Depth of Binary Tree 🌲 The task? Given the root of a binary tree, find the maximum depth — the number of nodes along the longest path from the root to a leaf node 🍃 💡 Intuition: A binary tree’s depth can be thought of as its “height”. To find it, we just need to know the depth of the left and right subtrees — and the answer is the greater of the two, plus one for the current node. This is a classic example of recursion done right — breaking a big problem into smaller ones that mirror the original. ⏱ Time Complexity: O(n) – visit every node once 🗂 Space Complexity: O(h) – h is the height of the tree (recursion stack) ✨ Key Takeaway: This problem beautifully highlights the power of divide and conquer — by solving smaller subproblems (left and right trees), we can elegantly solve the bigger one. #100DaysOfCode #Day60 #LeetCode #Java #CodingJourney #BinaryTree #Recursion #DataStructures #CodingPractice #ProblemSolving #WomenWhoCode #CodeNewbie #LearnToCode

💻 Day 34 — LeetCode 912: Sort an Array (Merge Sort Implementation) Today, I learned and implemented Merge Sort, a classic Divide and Conquer algorithm that efficiently sorts arrays with a time complexity of O(n log n). I applied it to LeetCode 912 (Sort an Array) — where the task is to sort an integer array without using built-in sorting methods. This problem helped me understand: How recursion splits the array into halves How merging combines sorted halves Why Merge Sort guarantees stable and consistent performance 🧠 Key takeaway: Merge Sort ensures O(n log n) in all cases (best, average, and worst), making it one of the most reliable sorting algorithms. #LeetCode #Day34 #DSA #SortingAlgorithms #MergeSort #CodingJourney #Java #ProblemSolving

🚀 Day 47 of My LeetCode Journey 🚀 Problem: Sum of Square Numbers Topic: Math / Two Pointers 🧠 Approach: To check if a number c can be expressed as the sum of squares of two integers (a² + b² = c), we use the two-pointer technique: Start a = 0 and b = √c Calculate sum = a² + b² If sum == c → ✅ return true If sum < c → increase a If sum > c → decrease b Repeat until a <= b. ⏱️ Complexity: Time: O(√c) Space: O(1) This problem beautifully combines mathematical logic with an efficient two-pointer approach — clean and elegant! 💡 #100DaysOfCode #LeetCode #Java #CodingChallenge #ProblemSolving #DSA

📅 Day 82 of #100DaysOfLeetCode Problem: Delete Node in a BST (LeetCode #450) Approach: The goal is to delete a node with a specific key from a Binary Search Tree (BST). The deletion process involves two main steps: Search for the node to be deleted. Delete it while maintaining the BST property. There are three cases when deleting a node: Leaf node: Simply remove it. One child: Replace the node with its child. Two children: Find the inorder successor (smallest value in the right subtree), replace the node’s value with it, and delete the successor recursively. Complexity: ⏱️ Time: O(h), where h is the height of the BST. 💾 Space: O(h), recursive call stack. 🔗 Problem Link: https://lnkd.in/dx4XEUgz 🔗 Solution Link: https://lnkd.in/d3-RJ6yJ #LeetCode #100DaysOfCode #BinarySearchTree #Recursion #Java #DSA #Algorithms #ProblemSolving #CodeNewbie #TreeTraversal #StudyWithMe #DailyCoding #BuildInPublic #LearnToCode #CodingJourney