Swamy Kanchanapally’s Post

🔥 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

#97day of #100DaysOfCode 🌳 LeetCode 1382: Balance a Binary Search Tree Today’s challenge was about restoring balance and harmony in a BST 🌿 Given an unbalanced BST, we need to transform it into a height-balanced BST — where no path is too long or too short. 🧠 Approach: 1️⃣ Perform inorder traversal to get a sorted list of all node values. 2️⃣ Build a balanced BST from that sorted list using divide and conquer. 📈 Complexity: Time: O(n) Space: O(n)💬 Learning: Balancing a tree is like balancing life — you can’t remove the nodes, but you can reorder your priorities 🌸 #LeetCode #DSA #BinarySearchTree #CodingChallenge #java #Algorithm #ProblemSolving #LeetCodeDaily #100DaysOfCode

📅 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

✅ 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 41 : Leetcode 153 - Find Minimum in Rotated Sorted Array #60DayOfLeetcodeChallenge 🧩 Problem Statement Given a sorted array that has been rotated at an unknown pivot, find the minimum element in the array. The array contains unique elements, and the solution must run in O(log n) time. 💡 My Approach I used a binary search technique to efficiently find the minimum element. I maintained two pointers, low and high. At each step, I calculated the mid-point. If the left part (nums[low] to nums[mid]) was sorted, I updated my answer with the smaller of nums[low] and current ans, and moved low to mid + 1. Otherwise, I updated my answer with nums[mid] and moved high to mid - 1. This approach ensures we keep narrowing the search space toward the minimum element. ⏱️ Time Complexity O(log n) — Because the search space is halved in each iteration. #BinarySearch #LeetCode #RotatedSortedArray #DSA #CodingPractice #Java #ProblemSolving

✅Day 54 : Leetcode 3228 - Maximum Number of Operations to Move Ones to the End #60DayOfLeetcodeChallenge 🧩 Problem Statement You are given a binary string s. You can perform the following operation any number of times: Choose an index i such that: i + 1 < s.length s[i] == '1' s[i+1] == '0' Then move this '1' to the right until it reaches the next '1' or the end of the string. Your task is to return the maximum number of such operations that can be performed. ✅ My Approach Instead of simulating every movement (which is slow), I used a counting strategy: 🔹 Key Idea Whenever I see a '1', I increase the count of ones seen so far. Whenever I see a pattern like …10…, this '1' can move past all previous ones, contributing extra operations equal to the number of '1's before it. 🔹 Steps Initialize: ones = 0 → counts how many '1' encountered so far. res = 0 → stores total operations. Traverse the string: If current char is '1' → increment ones. Else if the previous char is '1' (meaning we found 10) → add ones to result. Return res as the maximum operations. This avoids simulation and gives the optimal count directly. ⏱ Time Complexity O(n) — Single scan through the string O(1) space #dsa #leetcode #binarysearch #java #coding #problemsolving #100daysofdsa #interviewpreparation #learningeveryday #codingjourney

🌳 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 38 of My LeetCode Journey — Problem #2654 “Minimum Number of Operations to Make All Array Elements Equal to 1” (Java Solution) 💡 Today’s challenge beautifully combined number theory with algorithmic optimization. The goal: turn every element in an array into 1 using the minimum operations — and the key insight was rooted in GCD properties. 🔍 My thought process: If any 1s exist → we just need to handle the rest (n - count(1)). Otherwise → find the shortest subarray with GCD = 1, since it’s the only way to generate a 1. The final answer = minimal window length + (n - 1) operations. It’s fascinating how understanding mathematical relationships can drastically simplify code complexity 🔢 Each problem reminds me — elegant logic is what turns code into art 🧠💻 #Day38 #LeetCode #Java #ProblemSolving #NumberTheory #Algorithms #DSA #CodingJourney #100DaysOfCode #CodeEveryday #SoftwareEngineering #LearningInPublic #TechCommunity

💻 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