Valid Path in Grid using DFS with Directional Constraints

Subsets: Backtracking with Include/Exclude Decision Tree Generate all 2^n subsets via recursive binary choices — include current element or skip. Base case: processed all elements, save current subset. Backtracking pattern: modify state, recurse, undo modification. Backtracking Pattern: Modify shared state, explore branch, restore state before exploring alternate branch. This template applies to permutations, combinations, constraint satisfaction problems. Time: O(2^n) | Space: O(n) recursion depth #Backtracking #Subsets #DecisionTree #StateRestoration #Recursion #Python #AlgorithmDesign #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 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

Binary Tree Level Order Traversal: Queue with Level Isolation BFS naturally traverses level-by-level. Key technique: snapshot queue length before processing current level. Process exactly that many nodes, collecting values into level list while enqueueing children for next iteration. This prevents mixing levels. Level Isolation: Pre-loop length snapshot prevents newly-added children from affecting current level's iteration count. This pattern enables clean level-by-level processing. Time: O(n) | Space: O(w) where w = max width #BFS #LevelOrderTraversal #QueuePattern #TreeAlgorithms #Python #AlgorithmDesign #SoftwareEngineering

Binary Tree Right Side View: Last Node Per Level via BFS Right side view = rightmost node at each level. Level-order traversal with twist — track last non-null node processed in each level. That's the rightmost visible node from right perspective. Level Pattern Variation: Standard level-order with tracking twist. Last valid node per level solves problem elegantly. This "level + condition" pattern appears in zigzag traversal, vertical order. Time: O(n) | Space: O(w) #BFS #LevelOrder #RightSideView #TreeTraversal #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

Right Side View: Last Node Per Level via BFS Right side view = rightmost node at each level. Use level-order traversal, collect all nodes per level, then take last valid node. That's the rightmost visible from right perspective. Level Pattern Variation: Standard BFS with twist — extract specific element (last) from each level. This "level + condition" pattern appears in zigzag traversal, vertical order, boundary problems. Time: O(n) | Space: O(w) #BFS #LevelOrder #RightSideView #TreeTraversal #Python #AlgorithmDesign #SoftwareEngineering

Day 243 of #365DaysOfCode Solved Minimum Distance Between Three Equal Elements I using a hashmap-based indexing approach. Grouped indices of identical elements and evaluated triplets by scanning index lists to compute the minimum distance. This approach efficiently reduces redundant comparisons by leveraging value-based grouping. The solution runs in O(n) time with additional space for index storage. Continuing to refine problem solving through pattern recognition and efficient data organization. #365DaysOfCode #Day243 #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

A clean HMM.py utility for market regime detection with Hidden Markov Models. This module: - Trains a Gaussian HMM on the most recent 900 trading days - Accepts a DataFrame + configurable feature columns - Validates inputs and handles missing data - Returns both the fitted model and labeled output with: - hidden_state - per-state probabilities (state_prob_k) Designed it to be practical for quant workflows: reproducible (random_state), configurable (n_states, covariance_type, n_iter), and ready to plug into signal pipelines. #Python #QuantFinance #AlgorithmicTrading #SoftwareEngineering