Rotate Function LeetCode Problem Solution

Minimum Distance Between Three Equal Elements Thought process 🤔 Brute force: Run 3 loops, pick every (i, j, k), check if elements are equal, and calculate the absolute difference of indices. Keep updating the minimum. Simple approach, but yeah… O(n³) is too slow when input size grows 😅 How to optimize:: We only care about indices where values are the same, so instead of checking every triplet, let’s store them.. Use a map For each elem, store all its indices Then check only valid triplets from those indices, compute distances for valid groups and track the mini. O(n) time 💡 #leetcode #potd #programming #dsa #developer #softwareengineer #datastructures #algorithms 

Subtree of another tree Approach: If subRoot is null - return true If root is null - return false If values match - check isIdentical(root, subRoot) If identical - return true Else - check left and right: isSubtree(root.left, subRoot) isSubtree(root.right, subRoot) Return true if found anywhere, otherwise false TC: O(N*M) -- n =no. of nodes in root, m = no. nodes in subRoot (worst case) SC: O(h) -- height of tree ( O(N) -- skewed tree || O(logN) -- balanced tree) #coding #programming #DSA #Consistency #Leetcode #CodingJourney

49 of #100DaysOfCode Solved Next Greater Element II (LeetCode 503) using a Monotonic Stack + Circular Traversal approach 🔁 💡 Approach: Since the array is circular, we iterate 2 × n times to simulate wrapping around. Use a stack to store indices whose next greater element hasn’t been found yet. Traverse from left to right: If the current element is greater than the element at the index on top of the stack → update result. Keep popping until the stack condition breaks. Only push indices during the first pass (i < n) to avoid duplicates. ⚡ Key Insight: Using a monotonic decreasing stack helps us efficiently track elements waiting for their next greater value — reducing unnecessary comparisons. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(n) #LeetCode #DSA #Coding #Cpp #Programming #Stack #InterviewPrep

Post No: 046 I recently explored two ways of doing bit manipulation: std::bitset and unsigned int. std::bitset feels easier to understand because it lets us work with bits in a clear and readable way. We can directly access, set, reset, and flip bits using simple functions. It is great when learning because the code looks clean and less error-prone. On the other hand, unsigned int gives much more flexibility. We can use bitwise operators like &, |, ^, ~, <<, and >> to perform powerful operations. It is fast and is used a lot. (Though I still don’t understand much on how, when and where to use unsigned int) But with that flexibility comes responsibility. When using unsigned int, we need to be very careful about bit positions, shifting values, masks, and understanding what each operation is doing. A small mistake can easily give wrong results and may be hard to debug. #CPP #Programming #Coding #SoftwareDevelopment #Learning #Beginners

LCA - Lowest Common Ancestor of binary tree Approach: If current node is null, return null If current node is p or q, return current node Recursively search left and right If both sides return non-null → current node is LCA Otherwise → return the non-null side TC = O(n) SC = O(h) - depends on tree height (recursion stack) O(logn) - balanced tree O(n) - skewed tree #dsa #leetcode #consistency #coding #programming

🔀 Return codes hide your algorithm. Exceptions set it free. Look at a function full of return code checks. Somewhere inside all that nesting is the actual logic but you're reading two things at once. What happens when it works, and what happens when it doesn't. That's the real cost of return codes. They force two concerns into one structure, and neither one is readable on its own. Now look at the same function with exceptions: ✅ Verify the session ✅ Resolve the channel ✅ Moderate the content ✅ Broadcast to members Four steps. That's what the function does. The algorithm doesn't know about error handling. The error handling doesn't know about the algorithm. You can read either one without the other getting in the way. #CleanCode #Flutter #Dart #CodeQuality #SoftwareEngineering #Programming #DevTips #100DaysOfCode

Binary tree right side view Approach: - Keep a level variable - If level == result.size(), add current node (first node of that level) - Traverse right first, then left Time: O(n) Space: O(h) (worst: O(n), best: O(log n)) #Algorithms #DSA #LeetCode #coding #Programming

🚀 Solved: Smallest Window Containing 0, 1 and 2 (GFG Problem of the Day) Today I worked on an interesting sliding window problem that focuses on optimizing substring search efficiently. 🔍 Problem Statement: Given a string consisting only of '0', '1', and '2', find the length of the smallest substring that contains all three characters at least once. 💡 Approach Used: I applied the two-pointer / sliding window technique: Expand the window using the right pointer Track frequency of characters (0, 1, 2) Once all three are present, shrink the window from the left Update the minimum length dynamically ⚡ Why this approach? Instead of checking all substrings (O(n²)), sliding window reduces it to O(n) — making it efficient for large inputs. 📊 Complexity: Time: O(n) Space: O(1) 🧠 Key Learning: Efficient window shrinking is just as important as expansion in substring problems. ✨ Consistency in solving daily problems is helping me strengthen my problem-solving and optimization skills. #GeeksforGeeks #ProblemOfTheDay #DSA #SlidingWindow #Cpp #Coding #CompetitiveProgramming #100DaysOfCode

Day 70 of #100DaysOfCode 💻 Solved LeetCode 523 – Continuous Subarray Sum using an optimized Prefix Sum + HashMap approach. 💡 Key Insight: If two prefix sums have the same remainder when divided by k, the subarray between them is divisible by k. ⚡ Reduced time complexity from O(n²) → O(n) #leetcode #coding #dsa #cpp #programming #placements

51 of #100DaysOfCode Solved LeetCode 739 — Daily Temperatures using the Monotonic Stack approach 🔥 💡 Approach: Instead of checking every future day (which would be inefficient), I used a stack to store indices of temperatures in decreasing order. Traverse the array If the current temperature is higher than the one at the stack’s top, we’ve found the next warmer day Pop the index and calculate the difference Push the current index into the stack This ensures each element is processed only once — making it super efficient ⚡ ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) #leetcode #coding #dsa #cpp #programming #developers #tech #interviewprep