Rearrange Array Elements by Sign Using Two Pointers

✅ 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 21 of #DSAPrep > Problem: Check if Array is Sorted and Rotated > Platform: LeetCode > Concept: Array Traversal + Circular Indexing Solved this problem by counting the number of places where the array breaks the sorted order. If the array has at most one such break, it means the array is sorted and possibly rotated. > Key Idea: - Traverse the array and compare each element with the next element - Use modulo (%) to handle circular comparison (last element with first) - Count the number of decreasing points in the array - If count is less than or equal to 1, the array is valid > Time Complexity: O(n) > Space Complexity: O(1) #DSAPrep #Algorithms #Python #Arrays #ProblemSolving #CodingJourney

✅ Day 23 of #DSAPrep > Problem: Rotate Array > Platform: LeetCode > Concept: Array Manipulation Solved array rotation using the in-place reverse technique, avoiding extra space and improving efficiency. > Key Idea: Reverse the entire array first Reverse the first k elements Reverse the remaining elements Handle edge cases like empty array and k = 0 Use k % n for large rotations > Time Complexity: O(n) > Space Complexity: O(1) #DSAPrep #Algorithms #Python #Arrays #TwoPointers #ProblemSolving #CodingJourney

✅ Day 19 of #DSAPrep > Problem: Quick Sort > Concept: Divide and Conquer (Pivot & Partition) Learned Quick Sort, where an element is chosen as a pivot and the array is partitioned such that smaller elements are placed on the left and larger elements on the right. > Key Idea: - Choose a pivot element - Partition the array around the pivot - Recursively apply the same process on left and right subarrays > Time Complexity: O(n log n) > Space Complexity: O(log n) #DSAPrep #Algorithms #Python #Sorting #ProblemSolving #CodingJourney #DivideAndConquer

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

Find Minimum in Rotated Array: Binary Search with Rotation Detection Rotation breaks global order but one half stays sorted. Compare mid with right endpoint — if mid > right, minimum is in right half (rotation there). Otherwise, minimum in left or at mid. Track minimum while narrowing. Rotation Point Detection: Comparing mid with endpoint determines which half contains rotation/minimum. This partial ordering enables O(log n) despite global disruption. Time: O(log n) | Space: O(1) #BinarySearch #RotatedArray #MinimumFinding #RotationPoint #Python #AlgorithmDesign #SoftwareEngineering

Day 254 of #365DaysOfCode Solved Check if There is a Valid Path in a Grid using a DFS-based traversal with directional constraints. Each cell type defines allowed movement directions, and transitions are validated by ensuring bidirectional connectivity between adjacent cells. The traversal explores only feasible paths while maintaining a visited structure to avoid cycles. The solution runs in O(n × m) time and emphasizes careful handling of constrained graph traversal. Continuing to strengthen understanding of grid-based graphs and state validation. #365DaysOfCode #Day254 #DSA #LeetCode #Python #Algorithms #DFS #Graphs #ProblemSolving #Consistency

Day 250 of #365DaysOfCode Solved Intervals Between Identical Elements using a hashmap with prefix sum optimization. Grouped indices of identical values and computed distances by leveraging prefix sums to avoid redundant pairwise calculations. This reduces the complexity from quadratic to linear over grouped indices. The approach efficiently calculates contributions from both left and right sides for each index. Continuing to strengthen optimization techniques using prefix sums and grouping strategies. #365DaysOfCode #Day250 #DSA #LeetCode #Python #Algorithms #PrefixSum #HashMap #ProblemSolving #Consistency

Day 32/100 – Diameter of Binary Tree Today’s problem looked simple on the surface, but it really tested my understanding of tree traversal and recursion. Key Insight: The diameter of a binary tree isn’t about paths from root—it’s about the longest path between any two nodes. The trick? At every node, calculate: Left subtree height Right subtree height Update diameter = left + right This turns a potentially complex problem into a smooth DFS + height calculation. What I learned: How to combine recursion with global state Thinking beyond root-based solutions Every node can be the "center" of the longest path Time Complexity: O(n) Space Complexity: O(h) Consistency > intensity. On to Day 33 #100DaysOfCode #DataStructures #Algorithms #LeetCode #Python #CodingJourney

🚀 Day 48 – LeetCode Journey Today’s challenge: Substring with Concatenation of All Words ✔️ Solved using sliding window + hashmap ✔️ Processed string in fixed-length chunks ✔️ Tracked word frequency efficiently 💡 Key Insight: Instead of checking every substring blindly, splitting the string into word-sized pieces and using a hashmap helps validate matches efficiently. Sliding window keeps the solution optimized. This problem was a great exercise in string manipulation, hashing, and window techniques 🧠 Consistency is the real game changer 🚀 #LeetCode #Day48 #SlidingWindow #HashMap #Strings #Python #ProblemSolving #CodingJourney #100DaysOfCode https://lnkd.in/gxf4RBT6