Rotating Arrays: Brute Force, Extra Space, and Optimized Solutions

🚀 Just solved the Contains Duplicate problem with a fresh perspective! Instead of going with the traditional sorting + two pointer approach, I used the property of Set (uniqueness) to achieve an O(n) time complexity solution. 💡 Approach: - Traverse the array once - Use a HashSet to track elements - If an element already exists → duplicate found ⚡ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔁 On the other hand, the sorting + two pointer approach gives: - Time: O(n log n) - Space: O(1) 👉 So it’s a classic trade-off: - Optimize time → use Set - Optimize space → use Sorting+two pointer Really enjoyed breaking down this problem and comparing approaches — small problems like this build strong intuition for bigger ones 💪 #DataStructures #Algorithms #LeetCode #Java #CodingJourney #ProblemSolving #100DaysOfCode

🚀 Day 86 – DSA Journey | Path Sum in Binary Tree Continuing my daily DSA practice, today I worked on a problem that strengthened my understanding of recursion and root-to-leaf traversal. 📌 Problem Practiced: Path Sum (LeetCode 112) 🔍 Problem Idea: Determine if there exists a root-to-leaf path in a binary tree such that the sum of node values equals a given target. 💡 Key Insight: Instead of tracking the full path, we can reduce the problem by subtracting the current node’s value from the target as we traverse down the tree. 📌 Approach Used: • If the node is null → return false • Check if it is a leaf node – If yes, compare node value with remaining target • Subtract current node value from target • Recursively check left and right subtrees • If any path matches → return true 📌 Concepts Strengthened: • Tree traversal • Recursion • Root-to-leaf path logic • Problem reduction technique ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(h) (recursion stack) 🔥 Today’s takeaway: Breaking down a problem step by step (reducing the target at each node) makes recursion much more intuitive. On to Day 87! 🚀 #Day86 #DSAJourney #LeetCode #BinaryTree #Recursion #Java #ProblemSolving #Coding #LearningInPublic #Consistency

🚀 LeetCode Challenge 10/50 🔍 Problem: Merge Sorted Array Today’s problem focused on efficiently merging two sorted arrays without using extra space. 💡 Approach: I used the Two Pointer technique (from the end): Started comparing elements from the back of both arrays Placed the larger element at the end of nums1 Continued this process until all elements were merged ⚡ This approach avoids unnecessary shifting and works in-place. 📊 Complexity Analysis: Time Complexity: O(m + n) Space Complexity: O(1) 📚 Key Learning: Thinking from the end can simplify problems and avoid extra operations. Two-pointer technique is extremely useful for array manipulation problems. Consistency is building confidence 💪 #LeetCode #Algorithms #DataStructures #ProblemSolving #CodingJourney #Java #100DaysOfCode #StudentDeveloper #Learning

## 🧩 Solved LeetCode 9 – Palindrome Number Today I revisited a fundamental integer manipulation problem: determining if a number reads the same forward and backward without converting it to a string. 🔍 **Problem Insight:** While string conversion makes this trivial, the real challenge is solving it mathematically. The goal is to reverse the integer (or half of it) and compare it to the original while being mindful of potential integer overflow. 💡 **Key Learnings:**  * **Negative Numbers:** Any negative number is immediately invalid (e.g., -121 becomes 121-).  * **Mathematical Reversal:** Using modulo % 10 and integer division / 10 allows us to "pop" and "push" digits.  * **Optimization:** We only need to reverse **half** of the number. Once the original number becomes less than or equal to the reversed half, we've reached the middle.  * **Edge Case Savvy:** Numbers ending in 0 (except 0 itself) cannot be palindromes. ⚙️ **Approach Used:**  1. Eliminate negative numbers and numbers ending in 0.  2. Build the reversed half of the number by iteratively taking the last digit.  3. Stop when the reversed part is \ge the remaining part.  4. Check for equality (handling odd-lengthed numbers by dividing the reversed part by 10). 📊 **Complexity:**  * **Time:** O(\log_{10}(n)) — we divide the input by 10 in every iteration.  * **Space:** O(1) — constant space used regardless of input size. 🔥 **Takeaway:** This problem is a perfect example of why we shouldn't always reach for the easiest data type conversion. Thinking in terms of pure logic and math often leads to a more memory-efficient and elegant solution. #LeetCode #Algorithms #Math #ProblemSolving #CodingJourney #Java #DataStructures #CompetitiveProgramming

Worked on a challenging problem: “Subarrays with K Different Integers” Key takeaway: Instead of directly solving for exactly K distinct elements, I learned a smarter approach: 👉 count(at most K) − count(at most K−1) 🔹 Concepts I practiced: Sliding Window technique HashMap for frequency tracking Two-pointer approach 🔹 What stood out: The idea of counting all valid subarrays ending at each index using (r - l + 1) was really powerful. It completely changed how I think about subarray problems. Always learning, one problem at a time. #DataStructures #Algorithms #Java #LeetCode #SlidingWindow #LearningJourney #ProblemSolving

🚀 Day 81 – DSA Journey | Binary Tree Inorder Traversal Continuing my daily DSA practice, today I explored tree traversal and how stacks can simulate recursion. 📌 Problem Practiced: Binary Tree Inorder Traversal (LeetCode 94) 🔍 Problem Idea: Traverse a binary tree in inorder sequence — Left → Root → Right — and return the values of nodes. 💡 Key Insight: Instead of recursion, we can use a stack to iteratively traverse the tree by going as left as possible, then processing nodes and moving right. 📌 Approach Used: • Use a stack to simulate recursion • Start from root and go to the leftmost node • Push nodes while moving left • Pop from stack, process the node • Move to the right subtree and repeat 📌 Concepts Strengthened: • Tree traversal (Inorder) • Stack usage in trees • Iterative vs recursive approaches • Understanding tree structure ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) 🔥 Today’s takeaway: Recursion can always be converted into iteration using stacks — understanding this gives more control over traversal logic. On to Day 82! 🚀 #Day81 #DSAJourney #LeetCode #BinaryTree #Stack #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 29 Solved LeetCode Problem #129 – Sum Root to Leaf Numbers Today I worked on a Binary Tree problem that focuses on DFS traversal and number formation from root-to-leaf paths. 🌳 🔹 Problem: Given a binary tree where each node contains digits (0–9), every root-to-leaf path forms a number. The goal is to calculate the total sum of all these numbers. 🔹 Example: Tree: [1,2,3] Paths: 1 → 2 = 12 1 → 3 = 13 Total Sum = 12 + 13 = 25 🔹 Approach: ✔ Use Depth First Search (DFS) ✔ Build the number while traversing the tree ✔ Multiply previous value by 10 and add the current digit ✔ When reaching a leaf node, add the number to the total sum ⏱ Time Complexity: O(n) 📦 Space Complexity: O(h) 💡 Key Learning: This problem helped strengthen my understanding of Binary Tree traversal and how recursive DFS can be used to carry state across nodes. Excited to keep improving my problem-solving skills! 💻🔥 #leetcode #datastructures #algorithms #java #binarytree #coding #softwaredeveloper #codingjourney

Day 105: Circular Arrays & Shortest Paths 🔄 Problem 2515: Shortest Distance to Target String in a Circular Array Today’s challenge involved finding the minimum steps to reach a target string in a circular array, allowing movement in both directions. The Strategy: • Bidirectional Search: Since the array is circular, the distance can be calculated in two ways: moving forward or moving backward. • Modular Arithmetic: I used (dist + n) % n to handle the wrap-around logic seamlessly, ensuring the index stays within bounds regardless of the direction. • Optimization: By iterating once through the array and comparing the distances for every occurrence of the target, I maintained an O(N) time complexity. Sometimes the most elegant way to handle a "circular" problem is simply embracing the symmetry of the path. 🚀 #LeetCode #Java #Algorithms #ProblemSolving #DailyCode

🚀 Day 63 of #100DaysOfLeetCode ✅ Problem Solved: Unique Binary Search Trees (LeetCode 96) Today’s problem was a great example of how Dynamic Programming and mathematical patterns (Catalan Numbers) come together. 🔍 Key Insight: For every node chosen as root, the number of unique BSTs is: 👉 Left Subtrees × Right Subtrees This leads to the recurrence: dp[n] = Σ (dp[left] × dp[right]) 💡 What I learned: Breaking problems into smaller subproblems makes complex structures easier Recognizing patterns like Catalan Numbers is a game changer DP is not just about arrays, it's about thinking smart ⚡ Result: ✔️ Runtime: 0 ms (Beats 100%) ✔️ Clean and optimized solution Consistency is slowly turning into confidence 💪 #LeetCode #DataStructures #DynamicProgramming #CodingJourney #ProblemSolving #Java #100DaysOfCode