Binary Search with Insertion Index in O(log n) Time

Search Insert Position: Left Pointer as Natural Insertion Index When binary search terminates without finding target, left pointer automatically points to correct insertion position. No special handling needed — the loop invariant guarantees left is where target belongs to maintain sorted order. Termination Property: When l >= r, left has crossed to insertion position. This binary search property eliminates need for post-loop calculation. Time: O(log n) | Space: O(1) #BinarySearch #InsertPosition #LoopInvariant #SortedArrays #Python #AlgorithmDesign #SoftwareEngineering

Search Rotated Sorted Array: Binary Search with Sorted Half Detection Rotation breaks global order but one half is always properly sorted. Determine which half is sorted by comparing mid with endpoints. If target falls within sorted half's range, search there; otherwise search rotated half. Preserves O(log n). Partial Invariant: When global invariant breaks, find preserved local properties. Here, one half always maintains sorting despite rotation. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #PartialInvariant #SearchOptimization #Python #AlgorithmDesign #SoftwareEngineering

✅ Day 26 of #DSAPrep > Problem: Merge Sorted Array > Platform: LeetCode > Concept: Two Pointers / Merge Technique Solved this problem by merging two sorted arrays using two pointers and storing the result in sorted order. > Key Idea: Use one pointer for each array Compare current elements Insert smaller value into result Add remaining elements at the end > Time Complexity: O(m + n) > Space Complexity: O(m + n) #DSAPrep #Algorithms #Python #TwoPointers #Arrays #ProblemSolving #CodingJourney

Search 2D Matrix: Two Binary Searches for O(log m + log n) Treating matrix as flat array needs complex indexing. Cleaner: two sequential binary searches — first finds correct row (compare against first/last elements), second searches within that row. Exploits both sorted dimensions independently. Two-Phase Decomposition: Break 2D problem into sequential 1D searches when structure allows. Clearer than single-pass coordinate arithmetic. Time: O(log m + log n) | Space: O(1) #BinarySearch #2DMatrix #TwoPhaseSearch #SearchOptimization #Python #AlgorithmDesign #SoftwareEngineering

💡 Solved Group Anagrams today! 🧠 Key idea: Instead of comparing strings, I used a frequency array (size 26) to create a unique key for each word. ⚠️ Catch in constraints: All characters are lowercase English letters, which allows us to use a fixed-size array of 26 for efficient hashing. 🚀 Result: Achieved O(n · k) time complexity. Great example of converting a comparison problem into a hashing problem! #LeetCode #DSA #Algorithms #Python #CodingInterview

Top K Frequent: Bucket Sort Beats Heap with O(n) Time Heap solution costs O(n log k). Bucket sort achieves O(n) by exploiting constraint — frequencies ≤ array length. Index represents frequency, value is list of elements with that frequency. Traverse high-to-low, collecting k elements. Bucket Sort Advantage: When value range is bounded (frequencies ≤ n), bucket sort beats comparison-based sorting. Exploiting constraints transforms complexity. Time: O(n) | Space: O(n) #BucketSort #TopK #FrequencyAnalysis #ComplexityReduction #Python #AlgorithmOptimization #SoftwareEngineering

Subsets: Classic Backtracking Template Generate all 2^n subsets via binary decision tree — include or exclude each element. Base case: index exceeds array length, save current subset copy. Backtracking: add element, recurse, remove element (backtrack), recurse again. Critical Detail: subset.copy() is essential — without it, all results reference same list, causing incorrect final output. Each subset snapshot must be independent. Time: O(2^n) | Space: O(n) recursion #Backtracking #Subsets #DecisionTree #DeepCopy #Recursion #Python #AlgorithmDesign #SoftwareEngineering

✅ Day 18 of #DSAPrep > Problem: Insertion Sort > Concept: Sorting Algorithm Learned Insertion Sort, where elements are picked one by one and placed at the correct position in the sorted part of the array. > Key Idea: - Start from second element - Compare with previous elements - Shift elements to insert at correct position > Time Complexity: O(n²) > Space Complexity: O(1) #DSAPrep #Algorithms #Python #Sorting #ProblemSolving #CodingJourney

Search Rotated Sorted Array: Binary Search with Sorted Half Detection Rotation disrupts global order but one half stays sorted always. Determine which half is sorted by comparing mid with endpoints. If target falls within sorted half's range, search there; otherwise search rotated half. Preserves O(log n). Partial Invariant: When global invariant breaks, find preserved local properties. One half maintains sorting despite rotation — exploit this for logarithmic search. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #PartialInvariant #SearchOptimization #Python #AlgorithmDesign #SoftwareEngineering

📌 Problem: Reverse Vowels of a String 💡 Approach: Used the two-pointer technique to reverse only the vowels in the string. Initialize one pointer at the beginning and one at the end. Move both pointers inward until vowels are found, then swap them. Continue this process until both pointers meet. ⚙️ Key Insight: Use a set for fast vowel lookup (O(1)) Two-pointer approach avoids extra space for storing vowels separately ⏱️ Time Complexity: O(n) 📦 Space Complexity: O(n) (due to string → list conversion) 📚 What I learned: Efficient string manipulation using two pointers Optimizing lookups with hash sets #LeetCode #DSA #Algorithms #Coding #ProblemSolving #Python #TwoPointers #InterviewPreparation #CodingJourney