Hidden Markov Model Utility for Market Regime Detection

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 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

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

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

🗓 7 April 2026 LeetCode Problem #128 – Longest Consecutive Sequence Solved the problem of finding the longest consecutive sequence in an unsorted array. Key insight: use a set for O(1) lookups and only start counting sequences from numbers that are the beginning of a sequence. Takeaways: - Using the right data structure reduces time complexity from O(n²) to O(n). - Avoid redundant work while scanning arrays. - Handle edge cases like empty or single-element arrays efficiently. This problem reinforces how a smart approach beats brute force every time! #LeetCode #Algorithms #Python #DataStructures #ProblemSolving #Coding #TechLearning

📊 Everything in One Place: Bayesian Model Summary Plot 12 brings it ALL together: What's Inside: ✅ Posterior distributions (Intercept, Slope, Sigma) ✅ Regression with 95% credible interval ✅ Trace plots for convergence check ✅ Residual plot for validation The Story: - Slope: Tight distribution around 1.81 (precise!) - Trace plots: Perfect mixing (chains converged) - Residuals: Random scatter (model fits well) One dashboard. Complete Bayesian analysis. #Bayesian #DataScience #Python

Day 118 Backtracking patterns are repeating — and getting clearer. #Day118 🧩 39. Combination Sum How today went: • Used index i to control choices • Two options at each step: → stay at i (reuse same element) → move to i + 1 (try next element) • Track current total • If total == target → store result • If total > target → backtrack What clicked: It’s all about: → controlling index → tracking total → backtracking at the right time Same pattern, more confidence. #LeetCode #DSA #Python #Backtracking #Recursion #LearningInPublic #Consistency

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

Day 22/100 – DSA Journey Problem: Find Mode in Binary Search Tree (BST) Today’s problem focused on understanding how Binary Search Trees (BST) behave and how we can efficiently extract useful insights from them. Understanding the BST A Binary Search Tree follows a structured property: Left subtree → values ≤ root Right subtree → values ≥ root Because of this, when we perform an Inorder Traversal (Left → Root → Right), the values are visited in sorted order. Why Inorder Traversal? Since duplicates appear consecutively in a sorted sequence, inorder traversal allows us to: Track frequency without using extra space Compare current value with previous value Efficiently determine the most frequent element (mode) Approach Used Traverse the BST using inorder traversal Maintain: Previous value Current count Maximum frequency Update result list whenever a new maximum frequency is found Key Learning This problem highlights how leveraging tree properties can help optimize solutions. Instead of using extra space (like hashmaps), we used traversal behavior to achieve an efficient solution. Conclusion Understanding the underlying structure of data (like BST properties) is often more powerful than brute-force approaches. Smart traversal choices can significantly reduce space complexity and improve performance. #Day22 #100DaysOfCode #DSA #BinarySearchTree #Python #CodingJourney #LeetCode #ProblemSolving

🚗 Built an Automatic Number Plate Recognition (ANPR) System! Excited to share my recent project where I developed a real-time ANPR system using YOLOv8 and EasyOCR. 🔍 Key Features: • Real-time number plate detection • OCR-based text extraction • Custom dataset creation This project helped me strengthen my skills in Computer Vision and Machine Learning. 🔗 GitHub Repository: https://lnkd.in/g_5r5wcW #MachineLearning #ComputerVision #YOLO #Python #DataScience