Binary Search in Rotated Sorted Array with O(log n) Time

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

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

✅ 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

🚀 Day 70 of #100DaysOfCode Today’s problem: Find First and Last Position of Element in Sorted Array 🔍 At first, I thought of linear search… but the O(log n) hint changed everything. Had to dive into binary search and tweak it to find both first and last positions. 💡 What helped me: Run binary search twice → left bias & right bias Don’t stop at the first match, keep searching It’s all about controlling the search space smartly. Binary search is deeper than it looks. #DSA #LeetCode #CodingJourney #Python #BinarySearch

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

✅ Day 28 of #DSAPrep > Problem: Rearrange Array Elements by Sign > Platform: LeetCode > Concept: Array / Two Pointers Solved this problem using a two-pointer approach to place positive and negative numbers alternately in a new array. > Key Idea: Create a result array of same size Use one pointer for positive index (0,2,4...) Use another pointer for negative index (1,3,5...) Traverse input array and place elements accordingly > Time Complexity: O(n) > Space Complexity: O(n) #DSAPrep #Algorithms #Python #Arrays #TwoPointers #ProblemSolving #CodingJourney

Day 248 of #365DaysOfCode Solved a problem involving mirror pairs and index distance minimization using a hashmap-based approach. For each element, computed its digit-reversed counterpart and tracked indices to identify valid mirror pairs. The minimum distance was updated by comparing current positions with previously stored indices. The solution runs in O(n · d) time, where d is the number of digits, and efficiently leverages hashing for constant-time lookups. Continuing to build intuition around number manipulation and indexing strategies. #365DaysOfCode #Day248 #DSA #LeetCode #Python #Algorithms #HashMap #ProblemSolving #Consistency

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

Reorder List: Three-Phase In-Place Transformation Creating new list costs O(n) space. In-place approach: (1) find middle with slow/fast pointers, (2) reverse second half, (3) interleave both halves. Three independent phases keep logic clean while achieving O(1) space. Phase Decomposition: Breaking complex transformation into three known patterns (find middle, reverse, merge) simplifies implementation and debugging. Each phase is independently testable. Time: O(n) | Space: O(1) #LinkedList #InPlaceTransformation #PhaseDecomposition #ThreePointers #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