Binary Search for Insert Position in Sorted Array

🚀 Day 14 – DSA Daily Series Today’s Problem: Find Peak Element (LeetCode 162) Today I worked on an problem that focuses on identifying a peak element in an array. 🧠 Problem Given an array nums, return the index of any peak element. A peak element is an element that is greater than its neighbours. Example: Input: nums = [1,2,3,1] Output: 2 Explanation: 3 is greater than both its neighbours, so it is a peak element. 💡 Approach I solved this problem using Binary Search. Key idea: • Check the middle element mid • If nums[mid] > nums[mid + 1], a peak exists on the left side (including mid) • Otherwise, a peak exists on the right side • Continue narrowing the search space until the peak element is found This works because there will always be at least one peak in the array. ⏱ Complexity Time Complexity: O(log n) Space Complexity: O(1) 🔎 Key Learning Binary Search can be applied not only to sorted arrays but also to problems where we need to identify patterns or properties in the array. Continuing the DSA Daily Series — solving and learning one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #BinarySearch #CodingJourney #ProblemSolving

🚀 Day 10 – DSA Daily Series Today’s Problem: Search in Rotated Sorted Array (LeetCode 33) Today I solved an interesting problem where a sorted array is rotated, and we still need to find the target efficiently. 🧠 Problem You are given a sorted array that has been rotated at an unknown pivot. The task is to find the index of the target element. If the target is not present, return -1. Example: Input: nums = [4,5,6,7,0,1,2], target = 0 Output: 4 💡 Approach This problem is solved using a modified Binary Search. Key idea: • Even though the array is rotated, one half will always remain sorted • Check which half is sorted (left or right) • Determine whether the target lies in that sorted half • Adjust the search range accordingly By doing this, we can still achieve logarithmic time complexity. ⏱ Complexity Time Complexity: O(log n) Space Complexity: O(1) 🔎 Key Learning This problem helped me understand how Binary Search can be adapted for slightly complex scenarios like rotated arrays. Continuing the DSA Daily Series — solving and learning one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #BinarySearch #CodingJourney #ProblemSolving

🚀 Day 9 – DSA Daily Series Today’s Problem: Merge Sorted Array (LeetCode 88) Today I solved an interesting problem that involves merging two sorted arrays efficiently. 🧠 Problem You are given two sorted arrays nums1 and nums2. nums1 has enough extra space at the end to hold elements from nums2. The goal is to merge both arrays into a single sorted array inside nums1. Example: Input: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,5,6], n = 3 Output: [1,2,2,3,5,6] 💡 Approach Instead of creating a new array, I solved this using the two-pointer technique from the end. Steps followed: • Start pointers from the end of both arrays • Compare the elements from nums1 and nums2 • Place the larger element at the end of nums1 • Move the pointers accordingly until all elements are merged This approach avoids unnecessary shifting of elements. ⏱ Complexity Time Complexity: O(m + n) Space Complexity: O(1) 🔎 Key Learning Working from the end of the array is a smart trick that helps avoid overwriting elements while merging. Continuing the DSA Daily Series — improving problem-solving skills one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #CodingJourney #ProblemSolving

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) Return True if the values a and b are close to each other and False otherwise. Whether or not two values are considered close is determined according to given absolute and relative tolerances. If no errors occur, the result will be: abs(a-b) <= max(rel_tol * max(abs(a),abs(b)), abs_tol). rel_tol is the relative tolerance – it is the maximum allowed difference between a and b, relative to the larger absolute value of a or b. For example, to set a tolerance of 5%, pass rel_tol=0.05. The default tolerance is 1e-09, which assures that the two values are the same within about 9 decimal digits.  rel_tol must be nonnegative and less than 1.0. abs_tol is the absolute tolerance; it defaults to 0.0 and it must be nonnegative. When comparing x to 0.0, isclose(x, 0) is computed as abs(x) <= rel_tol  * abs(x), which is False for any nonzero x and rel_tol less than 1.0. So add an appropriate positive abs_tol argument to the call. The IEEE 754 special values of NaN, inf, and -inf will be handled according to IEEE rules. Specifically, NaN is not considered close to any other value, including NaN.  inf and -inf are only considered close to themselves. #python #softwaredevelopment #aiwithanisharya

Most people solve the Palindrome Number problem by converting the integer to a string and reversing it. It’s simple, readable, and honestly works perfectly in many real-world situations. But there’s another fast method that doesn’t use strings at all. Instead, you reverse the number mathematically — extracting digits one by one using division and modulo, then rebuilding the number in reverse order. This approach uses constant extra space and is often preferred in algorithm-focused environments. Both methods are efficient. The difference is mostly about tradeoffs: • String reversal → cleaner and more readable • Mathematical reversal → more optimal and lower-level Nice reminder that sometimes there’s a straightforward solution… and a slightly more “algorithmic” one — and knowing both makes you a stronger problem solver. 🚀 #Algorithms #ProblemSolving #Python #LeetCode #SoftwareEngineering

🚀 Day 11 – DSA Daily Series Today’s Problem: Find Minimum in Rotated Sorted Array (LeetCode 153) Today I solved an interesting problem that involves finding the minimum element in a rotated sorted array. 🧠 Problem You are given a sorted array that has been rotated several times. The task is to find the minimum element in the array. Example: Input: nums = [3,4,5,1,2] Output: 1 💡 Approach I solved this problem using Binary Search. Key idea: • In a rotated sorted array, the minimum element lies at the rotation point • Compare the middle element with the rightmost element • If nums[mid] > nums[high], the minimum lies in the right half • Otherwise, it lies in the left half including mid By narrowing the search space, we efficiently locate the minimum element. ⏱ Complexity Time Complexity: O(log n) Space Complexity: O(1) 🔎 Key Learning Binary Search can be extended beyond simple searching and used to identify structural properties of arrays like rotation points. Continuing the DSA Daily Series — solving and learning one problem at a time. 🚀 #DSA #LeetCode #Python #Algorithms #BinarySearch #CodingJourney #ProblemSolving

🚀Over the past few days, I’ve been focusing on understanding the different approaches used in Data Structures and Algorithms rather than directly jumping into solving random problems. I’ve been learning how to analyze a problem and decide which approach fits best. Some of the approaches I explored: • Brute Force Approach – solving problems in the simplest possible way • Optimal Solution Thinking – improving efficiency and reducing unnecessary operations • Two Pointers Technique – useful for array and string problems • Sliding Window – efficient for subarray and substring problems • Prefix Sum – helpful for range sum queries • Hashing / Dictionaries – fast lookups and frequency counting • Sorting-based approaches – simplifying comparisons and searches Understanding when to use these approaches is helping me build a strong problem-solving foundation before diving deeper into DSA topics like arrays, strings, trees, and graphs. #DSA #ProblemSolving #Algorithms #CodingJourney #Python #LearningInPublic #Placements Rudra Sravan kumar

🚀 Optimized Solution: Search in Rotated Sorted Array II Solved the problem "Search in Rotated Sorted Array II" using an optimized Binary Search approach! 🔍 Key Idea: Instead of using linear search, I applied a modified binary search to handle: ✔️ Rotated sorted array ✔️ Presence of duplicates ⚙️ Approach: Used binary search to divide the array Identified sorted halves even with duplicates Carefully handled edge cases where duplicates make it hard to decide the sorted side 📈 Complexity: ⏱️ Time Complexity: O(log n) (Worst case O(n) due to duplicates) 💾 Space Complexity: O(1) ✅ Result: ✔️ All test cases passed ⚡ Efficient and scalable solution This problem really helped me strengthen my understanding of edge cases in binary search and real-world problem-solving 💡 #leetcode #binarysearch #algorithms #coding #python #datastructures #softwaredeveloper #problemSolving

Day16-Problem of the day Given the root of a binary tree and an integer k, determine the number of downward-only paths where the sum of the node values in the path equals k. Why it works: By keeping track of the cumulative sums we've seen so far, we can determine if a sub-path summing to $k$ exists in $O(1)$ time at each node. It transforms a potential $O(N^2)$ bottleneck into a sleek $O(N)$ linear traversal. 🚀 Key Takeaway: Data structures like Hash Maps aren't just for flat arrays; they are incredibly powerful for optimizing recursive traversals by "remembering" the history of a branch. #CodingChallenge #DataStructures #Algorithms #Python #GFG #Learning

🔍 Debugging a Graph Problem: Longest Cycle in a Directed Graph Today I worked on an interesting problem — finding the longest cycle in a directed graph using DFS + cycle detection. Initially, my approach was correct, but I ran into errors due to small mistakes like: ❌ Typo in variable name (inCureentDfs) ❌ Wrong operator (. instead of -) ❌ Missing proper cycle detection handling After fixing them, the solution worked perfectly 🚀 💡 Key Concept: To detect a cycle and calculate its length: Use visited[] to track visited nodes Use inCurrentDfs[] to detect cycles Use dist[] to calculate cycle length 👉 Formula used: Cycle Length = dist[current] - dist[cycle_start] + 1 💻 Final Solution: class Solution: def longestCycle(self, V, edges): self.res = -1 self.next = [-1] * V for u, v in edges: if v != -1: self.next[u] = v self.visited = [False] * V self.dist = [0] * V self.inCurrentDfs = [False] * V def dfs(u): self.visited[u] = True self.inCurrentDfs[u] = True v = self.next[u] if v != -1: if not self.visited[v]: self.dist[v] = self.dist[u] + 1 dfs(v) elif self.inCurrentDfs[v]: self.res = max(self.res, self.dist[u] - self.dist[v] + 1) self.inCurrentDfs[u] = False for i in range(V): if not self.visited[i]: dfs(i) return self.res ✨ Learning: Sometimes, it's not about logic — it's about attention to detail. Small bugs can break the entire solution. #DataStructures #Algorithms #Python #CodingJourney #Debugging #GraphTheory #Learning