# sharingsource/logicstack-leetcode

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/sharingsource-logicstack-leetcode).**

7,495 stars · 940 forks · Apache-2.0

## Links

- GitHub: https://github.com/SharingSource/LogicStack-LeetCode
- Homepage: https://acoier.com/about/
- awesome-repositories: https://awesome-repositories.com/repository/sharingsource-logicstack-leetcode.md

## Topics

`algorithm` `interview-practice` `interview-questions` `leetcode` `offer` `programmers`

## Description

LogicStack-LeetCode is a curated repository of solved algorithm problems and data structure implementations, primarily drawn from the LeetCode platform. Its core identity is a structured collection of solutions designed to support technical interview preparation and competitive programming practice, with each solution accompanied by complexity analyses to help engineers understand performance trade-offs.

The repository distinguishes itself through its breadth of coverage across fundamental algorithmic patterns and data structures. It includes implementations for array manipulation, string processing, graph traversal, dynamic programming, backtracking, and tree operations, as well as specialized areas like game theory, computational geometry, and arithmetic expression evaluation. The collection also features custom data structure designs, including caches, hash maps, and time-based key-value stores, alongside foundational techniques such as binary search on answer spaces, prefix-sum-based range querying, and monotonic stack pattern matching.

The solutions are organized by topic tags, allowing users to browse problems by algorithmic category. The repository is updated daily with new solution write-ups, providing a continuously growing library of content for practicing common software assessment patterns.

## Tags

### Education & Learning Resources

- [Technical Interview Preparation](https://awesome-repositories.com/f/education-learning-resources/technical-interview-preparation.md) — Solves LeetCode algorithm problems with curated solutions and complexity analyses for software engineering interviews.
- [Complexity Analysis](https://awesome-repositories.com/f/education-learning-resources/algorithm-study-guides/sorting-algorithms/complexity-analysis.md) — Provides comparative evaluation of algorithms based on stability, time complexity, and memory usage. ([source](https://cdn.jsdelivr.net/gh/sharingsource/logicstack-leetcode@main/README.md))
- [Balanced BST Construction](https://awesome-repositories.com/f/education-learning-resources/balanced-bst-construction.md) — Implements algorithms for creating height-balanced BSTs from sorted arrays. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%88%86%E6%B2%BB))
- [Dynamic Programming Strategies](https://awesome-repositories.com/f/education-learning-resources/combinatorial-problem-solving/dynamic-programming-strategies.md) — Implements state machine, interval, digit, and tree DP strategies for optimization and combinatorial problems.
- [Data Structure Fundamentals](https://awesome-repositories.com/f/education-learning-resources/data-structure-fundamentals.md) — Builds and applies fundamental data structures like priority queues, tries, and hash maps to solve coding challenges.
- [Diameter Computations](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/diameter-computations.md) — Implements algorithms for finding the longest path between any two nodes in a binary tree. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Binary Tree Solutions](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/binary-tree-solutions.md) — Delivers binary tree and BST solutions with complexity analyses for mastering tree algorithms. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%8F%89%E6%A0%91))
- [Tree Dynamic Programming Solvers](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/tree-dynamic-programming-solvers.md) — Applies dynamic programming on tree structures to compute optimal values like path sums. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E5%BD%A2-DP))
- [Graph Traversal Algorithms](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/data-ordering-and-retrieval/graph-traversal-algorithms.md) — Traverses and analyzes graphs using BFS, DFS, topological sort, shortest path, and union-find algorithms.
- [Topological Ordering Solvers](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/topological-ordering-solvers.md) — Solves graph problems requiring topological sorting, such as course scheduling and dependency resolution. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F))
- [Union-Find Solvers](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/union-find-solvers.md) — Applies the disjoint-set data structure to group connected elements and answer connectivity queries. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%B9%B6%E6%9F%A5%E9%9B%86))
- [LeetCode Solution References](https://awesome-repositories.com/f/education-learning-resources/leetcode-solution-references.md) — Curates solved LeetCode problems with complexity analyses for interview preparation and competitive programming.
- [Interview Problem Solving](https://awesome-repositories.com/f/education-learning-resources/problem-solving-guides/interview-problem-solving.md) — Provides techniques for demonstrating problem-solving processes during interviews, including thinking out loud. ([source](https://cdn.jsdelivr.net/gh/sharingsource/logicstack-leetcode@main/README.md))
- [Two-Pointer Techniques](https://awesome-repositories.com/f/education-learning-resources/problem-solving-guides/interview-problem-solving/two-pointer-techniques.md) — Applies two-pointer techniques including sliding window and fast-slow pointers for array and string problems. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8F%8C%E6%8C%87%E9%92%88))
- [Sorted Matrix Search Patterns](https://awesome-repositories.com/f/education-learning-resources/sorted-matrix-search-patterns.md) — Finds a target value in a row-wise and column-wise sorted matrix by applying binary search across rows and columns. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Algorithmic Problem Solving](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving.md) — Provides educational resources focused on mastering computational logic and implementing efficient solutions. ([source](https://cdn.jsdelivr.net/gh/sharingsource/logicstack-leetcode@main/README.md))
- [Trie-Based Problem Solvers](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/bitwise-xor-problem-solving/trie-based-problem-solvers.md) — Solves trie data structure challenges including prefix trees, word search, and XOR queries. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%97%E5%85%B8%E6%A0%91))
- [Divide and Conquer Techniques](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/divide-and-conquer-techniques.md) — Provides solutions that break problems into smaller subproblems, solve each recursively, and combine results for the final answer. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%88%86%E6%B2%BB))
- [Memoization Techniques](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/memoization-techniques.md) — Applies top-down dynamic programming to cache intermediate results and avoid redundant computation in recursive solutions. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%AE%B0%E5%BF%86%E5%8C%96%E6%90%9C%E7%B4%A2))
- [Matrix Exponentiation](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/recurrence-relation-solving/matrix-exponentiation.md) — Solves linear recurrences using matrix exponentiation to achieve logarithmic time complexity. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E7%9F%A9%E9%98%B5%E5%BF%AB%E9%80%9F%E5%B9%82))
- [Competitive Programming Resources](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/technical-academic-domains/algorithmic-design-analysis/competitive-programming-resources.md) — Provides solutions for competitive programming challenges including game theory and computational geometry.
- [Bracket Validation Algorithms](https://awesome-repositories.com/f/education-learning-resources/bracket-validation-algorithms.md) — Provides algorithms that verify correct pairing and ordering of brackets in strings using stack-based parsing. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%8B%AC%E5%8F%B7%E9%97%AE%E9%A2%98))
- [BST Range Summation](https://awesome-repositories.com/f/education-learning-resources/bst-range-summation.md) — Sums all node values within a given numeric range in a binary search tree. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E7%9A%84%E6%90%9C%E7%B4%A2))
- [Combinatorial Problem Solving](https://awesome-repositories.com/f/education-learning-resources/combinatorial-problem-solving.md) — Provides educational resources and implementations for solving problems involving permutations and combinations. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%9E%E6%BA%AF%E7%AE%97%E6%B3%95))
- [Competitive Programming Solutions](https://awesome-repositories.com/f/education-learning-resources/competitive-programming-solutions.md) — Contains algorithm solutions spanning game theory, range queries, and advanced computational strategies.
- [Exponential Search](https://awesome-repositories.com/f/education-learning-resources/curricula-instructional-design/learning-methodologies-exercises/array-based-search-exercises/exponential-search.md) — Finds a target in a sorted array of unknown length by first expanding the search range exponentially. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Binary Search Version Finders](https://awesome-repositories.com/f/education-learning-resources/depth-first-search-implementations/binary-search-version-finders.md) — Identifies the first version in a sequence that causes a failure, using binary search on the version list. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Iterative Deepening Search](https://awesome-repositories.com/f/education-learning-resources/depth-first-search-implementations/search-depth-limiting/iterative-deepening-search.md) — Explores a search space by gradually increasing the depth limit, combining depth-first memory use with breadth-first completeness. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E8%BF%AD%E4%BB%A3%E5%8A%A0%E6%B7%B1))
- [Level-Order Traversals](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/level-order-traversals.md) — Visits every node of a tree one depth at a time using a queue-based breadth-first approach. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/BFS))
- [Binary Tree Width Calculators](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/binary-tree-width-calculators.md) — Computes the maximum width of a binary tree using index-based level tracking. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Level-Wise Maximum Value Finders](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/level-wise-maximum-value-finders.md) — Finds the maximum value in each row of a binary tree through level-order traversal. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/BFS))
- [Longest Distinct Neighbor Paths](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/longest-distinct-neighbor-paths.md) — Implements DFS-based longest path finding in trees with distinct neighbor character constraints. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Maximum Element Tree Constructions](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-algorithmic-problems/maximum-element-tree-constructions.md) — Constructs binary trees by recursively selecting maximum elements from array subranges. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%88%86%E6%B2%BB))
- [Tree Serialization](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/algorithm-data-structure-guides/binary-trees/tree-serialization.md) — Converts binary trees to and from string representations for persistence and transmission. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/BFS))
- [Character Frequency Sorting](https://awesome-repositories.com/f/education-learning-resources/frequency-based-sorting/character-frequency-sorting.md) — Provides algorithms that sort strings based on the frequency of individual characters. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Depth-First Search Algorithms](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/depth-first-search-algorithms.md) — Implements depth-first search for exhaustive graph traversal and pathfinding. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/DFS))
- [Depth-First Search Problem Solving](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/depth-first-search-problem-solving.md) — Provides DFS-based solutions for graph and tree pathfinding and connectivity challenges. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Shortest Path Algorithms](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/shortest-path-algorithms.md) — Solves shortest path challenges in graphs with complexity analyses for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%9C%80%E7%9F%AD%E8%B7%AF))
- [Topological Ordering Algorithms](https://awesome-repositories.com/f/education-learning-resources/graph-problem-solving/topological-ordering-algorithms.md) — Solves dependency ordering problems using topological sort on directed acyclic graphs. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F))
- [Sudoku Board Validation](https://awesome-repositories.com/f/education-learning-resources/puzzle-validation-algorithms/sudoku-board-validation.md) — Checks 9x9 Sudoku grids for rule violations using hash sets for rows, columns, and sub-boxes. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Negative Number Counts in Sorted Matrices](https://awesome-repositories.com/f/education-learning-resources/sorted-matrix-search-patterns/negative-number-counts-in-sorted-matrices.md) — Ships a binary-search-based solution for counting negatives in sorted matrices. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Bitwise XOR Problem Solving](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/bitwise-xor-problem-solving.md) — Provides curated LeetCode solutions for bit manipulation challenges including counting bits and Hamming distances. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BD%8D%E8%BF%90%E7%AE%97))
- [Bit Manipulation Solutions](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving/bitwise-xor-problem-solving/bit-manipulation-solutions.md) — Presents solutions for bit-level challenges to deepen understanding of bitwise operations. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A8%A1%E6%8B%9F))
- [Word Break Checkers](https://awesome-repositories.com/f/education-learning-resources/word-dictionaries/word-break-checkers.md) — Implements a word break check using dynamic programming and hash sets. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))

### Data & Databases

- [Least Recently Used Caches](https://awesome-repositories.com/f/data-databases/data-engineering-infrastructure/caching-performance/caching/least-recently-used-caches.md) — Implements a least-recently-used cache with constant-time get and put operations using a hash map and doubly linked list. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [K-Distance Node Search](https://awesome-repositories.com/f/data-databases/distance-based-node-discovery/k-distance-node-search.md) — Implements algorithms for finding all nodes exactly K hops away from a target node in a tree. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Top-K Element Identification](https://awesome-repositories.com/f/data-databases/top-k-element-identification.md) — Returns the k most frequent elements using hash-map frequency counting and heap selection. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Closest Element Identification](https://awesome-repositories.com/f/data-databases/top-k-element-identification/closest-element-identification.md) — Retrieves k elements from a sorted array that are closest to a given target value using binary search. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Graph Cycle Detection](https://awesome-repositories.com/f/data-databases/graph-computing-systems/graph-theory/graph-libraries/graph-cycle-detection.md) — Implements cycle detection in directed graphs using visited and processing state tracking. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F))
- [Graph Traversal](https://awesome-repositories.com/f/data-databases/graph-traversal.md) — Implements breadth-first search for level-order graph traversal and shortest path finding. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-BFS))
- [Hash Maps](https://awesome-repositories.com/f/data-databases/hash-maps.md) — Provides implementations of hash maps for efficient key-value storage and retrieval. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Node Reachability Analyses](https://awesome-repositories.com/f/data-databases/node-reachability-analyses.md) — Computes the number of nodes reachable from each node in a directed graph. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E6%8B%93%E6%89%91%E6%8E%92%E5%BA%8F))

### Development Tools & Productivity

- [Boolean Expression Evaluation](https://awesome-repositories.com/f/development-tools-productivity/automation-template-customizations/boolean-expression-evaluation.md) — Ships a parser that evaluates boolean expressions with AND, OR, NOT, and nested parentheses. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AE%A1%E7%AE%97))
- [Technical Interview Preparation](https://awesome-repositories.com/f/development-tools-productivity/technical-interview-preparation.md) — Provides a structured set of solved programming challenges and algorithm patterns for mastering software assessments.

### Programming Languages & Runtimes

- [Hash Table Lookups](https://awesome-repositories.com/f/programming-languages-runtimes/hash-table-lookups.md) — Provides hash map implementations for constant-time key-value lookups and frequency counting.
- [Array Shufflers](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/standard-libraries/standard-library-implementations/sequence-algorithms/randomization-algorithms/array-shufflers.md) — Rearranges array elements into uniformly random permutations using the Fisher-Yates algorithm. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%B4%97%E7%89%8C%E7%AE%97%E6%B3%95))
- [Floor and Ceil Searchers](https://awesome-repositories.com/f/programming-languages-runtimes/range-search-and-sort/extreme-element-search/floor-and-ceil-searchers.md) — Finds the largest element less than or equal to a target and the smallest element greater than or equal to it in a sorted array. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Algorithm Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/algorithm-implementations.md) — Provides reusable implementations of segment trees, Fenwick trees, and matrix exponentiation.
- [Binary Search Trees](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/binary-search-trees.md) — Implements binary search tree search operations for locating target values. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E7%9A%84%E6%90%9C%E7%B4%A2))
- [Fenwick Trees](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/fenwick-trees.md) — Implements Fenwick trees for efficient prefix sum queries and logarithmic-time updates. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E7%8A%B6%E6%95%B0%E7%BB%84))
- [Parentheses Generation](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/standard-libraries/standard-library-implementations/sequence-algorithms/bracket-balancing-algorithms/parentheses-generation.md) — Implements algorithms for generating all valid combinations of balanced bracket sequences. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%8B%AC%E5%8F%B7%E9%97%AE%E9%A2%98))
- [Extreme Element Search](https://awesome-repositories.com/f/programming-languages-runtimes/range-search-and-sort/extreme-element-search.md) — Finds the start and end indices of all occurrences of a target value in a sorted array. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))

### Scientific & Mathematical Computing

- [Binary Search on Answer Space](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-search-on-answer-space.md) — Finds the smallest or largest value satisfying a monotonic condition using binary search on the answer space. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Predicate-Based Element Counters](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-search-on-answer-space/predicate-based-element-counters.md) — Counts or finds the k-th smallest element satisfying a predicate using binary search on the answer space. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Knapsack Problem Solving](https://awesome-repositories.com/f/scientific-mathematical-computing/dynamic-programming/knapsack-problem-solving.md) — Applies dynamic programming to partition, subset-sum, and resource-allocation challenges commonly found in technical interviews. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%83%8C%E5%8C%85-DP))
- [Integer Palindrome Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/integer-palindrome-algorithms.md) — Determines if an integer is a palindrome without string conversion using mathematical reversal. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%9E%E6%96%87%E4%B8%B2%E9%97%AE%E9%A2%98))
- [Linked List Cycle Detectors](https://awesome-repositories.com/f/scientific-mathematical-computing/linked-list-cycle-detectors.md) — Uses fast and slow pointers to determine whether a linked list contains a cycle and find its starting node. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8F%8C%E6%8C%87%E9%92%88))
- [Arithmetic Expression Evaluators](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/arithmetic-operations/arithmetic-expression-evaluators.md) — Implements a stack-based evaluator for arithmetic expressions with operator precedence. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AE%A1%E7%AE%97))
- [Exponentiation Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/exponentiation-algorithms.md) — Provides binary exponentiation implementations for efficient large-exponent computation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%BF%AB%E9%80%9F%E5%B9%82))
- [2D Prefix Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/2d-prefix-sums.md) — Precomputes 2D prefix sums for constant-time rectangular sub-region sum queries. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Prefix XOR Range Queries](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/prefix-xor-range-queries.md) — Implements prefix XOR range queries to answer subarray XOR queries in constant time. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Prefix Sum Queries](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/string-prefix-sums/prefix-sum-queries.md) — Precomputes prefix sums and XORs to answer subarray aggregate queries in constant time. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Subarray Target Sum Locators](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/subarray-target-sum-locators.md) — Implements prefix-sum and hash-map algorithms to count subarrays summing to a target value. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Tree Reconstruction](https://awesome-repositories.com/f/scientific-mathematical-computing/recursive-tree-traversal-algorithms/tree-reconstruction.md) — Implements algorithms for rebuilding tree structures from traversal sequences or ancestor constraints. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91))
- [Sorted Array Boundary Search](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-boundary-search.md) — Identifies the first and last occurrence of a target value within a sorted array using binary search. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Rotated Sorted Array Search](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-management/rotated-sorted-array-search.md) — Identifies the minimum element or pivot point in a rotated sorted array using binary search. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Rotated Array Duplicate Searchers](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-management/rotated-sorted-array-search/rotated-array-duplicate-searchers.md) — Finds a target in a rotated sorted array that may contain duplicate values, handling ambiguity in binary search. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Sorted Array Search Implementations](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-search-implementations.md) — Provides standard binary search implementations for locating elements or insertion points in sorted arrays. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [BST Conversions](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-search-implementations/bst-conversions.md) — Implements algorithms for transforming sorted arrays or linked lists into balanced BSTs. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E7%9A%84%E6%90%9C%E7%B4%A2))
- [Median Partitioning](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-search-implementations/median-partitioning.md) — Implements the classic median of two sorted arrays problem using binary search and partition optimization. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%88%86%E6%B2%BB))
- [Minimum Length Subarray Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/minimum-length-subarray-sums.md) — Implements the classic minimum length subarray with sum at least target problem using sliding window and prefix sums. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Maximum Subarray Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/minimum-length-subarray-sums/contiguous-subarray-processing/maximum-subarray-sums.md) — Implements the classic maximum subarray sum problem using Kadane's algorithm and prefix-sum techniques. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Trapped Water Calculations](https://awesome-repositories.com/f/scientific-mathematical-computing/trapped-water-calculations.md) — Measures trapped water between elevations using two-pointer or stack approaches. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%95%E8%B0%83%E6%A0%88))
- [Tree Distance Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/tree-distance-sums.md) — Implements algorithms for calculating cumulative distances between all node pairs in a tree. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Peak Element Search](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-search-algorithms/peak-element-search.md) — Identifies peak elements in arrays where neighbors are smaller using binary search on the slope. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Previous Smaller Element Searches](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-search-algorithms/peak-element-search/previous-smaller-element-searches.md) — Implements binary search to find the immediate predecessor of a target in a sorted array. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Bipartite Graph Detection](https://awesome-repositories.com/f/scientific-mathematical-computing/bipartite-graph-detection.md) — Implements bipartite graph detection via node coloring during traversal. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Nested Expression Parsers](https://awesome-repositories.com/f/scientific-mathematical-computing/nested-expression-parsers.md) — Implements algorithms for analyzing and calculating values from nested parenthetical or algebraic expressions. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%88))
- [Functional Graph Analysis](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/graph-processing/functional-graph-analysis.md) — Implements functional graph analysis for graphs where each node has exactly one outgoing edge. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E5%9F%BA%E7%8E%AF%E6%A3%AE%E6%9E%97))
- [Minimum Spanning Tree Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/graph-processing/minimum-spanning-tree-algorithms.md) — Implements Kruskal's and Prim's algorithms for minimum spanning tree construction. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%9C%80%E5%B0%8F%E7%94%9F%E6%88%90%E6%A0%91))
- [Tree-Based Fuel Minimization](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/graph-processing/minimum-spanning-tree-algorithms/tree-based-fuel-minimization.md) — Calculates minimum fuel required for cars to converge at a capital node in a tree. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Longest Palindromic Substring Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/string-algorithms/palindromic-sequence-analyzers/longest-palindromic-substring-algorithms.md) — Implements algorithms for finding the longest palindromic substring within a given string. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%9E%E6%96%87%E4%B8%B2%E9%97%AE%E9%A2%98))
- [Palindrome Partitioning Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/string-algorithms/palindromic-sequence-analyzers/palindrome-partitioning-algorithms.md) — Implements algorithms for optimizing palindromic substring partitioning using arithmetic progression grouping. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%9E%E6%96%87%E4%B8%B2%E9%97%AE%E9%A2%98))
- [Bitmask Subset Iterators](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/bitmask-subset-iterators.md) — Implements algorithms for efficiently traversing all subsets of a given bitmask. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E8%BF%9B%E5%88%B6%E6%9E%9A%E4%B8%BE))
- [Target XOR Subarray Counters](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/bitwise-manipulation-utilities/range-bitwise-operations/bitwise-xor-operations/prefix-xor-tracking/target-xor-subarray-counters.md) — Implements prefix-XOR and hash-map algorithms to count subarrays with a target XOR value. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Perfect Square Validators](https://awesome-repositories.com/f/scientific-mathematical-computing/perfect-square-validators.md) — Verifies whether an integer is a perfect square using binary search on the number line. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Maximum Submatrix Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/2d-prefix-sums/maximum-submatrix-sums.md) — Solves a specific LeetCode problem using 2D prefix sums to find the maximum submatrix sum under a limit. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Target Sum Submatrix Counters](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/2d-prefix-sums/target-sum-submatrix-counters.md) — Uses 2D prefix sums and hash maps to count submatrices whose elements sum to a given value. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Maximum Frequency After Increments](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/frequency-analysis/maximum-frequency-after-increments.md) — Solves a specific LeetCode problem using prefix sums to compute maximum achievable frequency after increments. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Minimum Index Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/string-prefix-sums/minimum-index-sums.md) — Solves a specific LeetCode problem using hash maps to find the common string with the smallest index sum. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Equal Count Subarrays](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-algorithms/subarray-target-sum-locators/equal-count-subarrays.md) — Ships prefix-sum techniques for locating subarrays with equal counts of two element types. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Maximum Score Path Computations](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-sum-path-optimization/maximum-score-path-computations.md) — Solves a specific LeetCode problem using prefix sums to compute maximum score when traversing two sorted arrays. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Iterative Deepening Search](https://awesome-repositories.com/f/scientific-mathematical-computing/recursive-tree-traversal-algorithms/binary-tree-traversals/iterative-deepening-search.md) — Finds nodes at a specific distance from a target by performing iterative deepening depth-first search on a tree structure. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E8%BF%AD%E4%BB%A3%E5%8A%A0%E6%B7%B1))
- [Bitonic Array Searches](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-management/rotated-sorted-array-search/bitonic-array-searches.md) — Implements binary search to locate targets in mountain-shaped arrays by finding the peak first. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Nearly Sorted Array Searches](https://awesome-repositories.com/f/scientific-mathematical-computing/sorted-array-search-implementations/nearly-sorted-array-searches.md) — Provides a binary search variant for nearly sorted arrays, a common interview pattern. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [State-Space Game Search](https://awesome-repositories.com/f/scientific-mathematical-computing/state-space-game-search.md) — Explores all possible game states using recursion and memoization to determine winning positions. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))
- [Disjoint Subarray Sums](https://awesome-repositories.com/f/scientific-mathematical-computing/subarray-sum-algorithms/disjoint-subarray-sums.md) — Solves the maximum sum of non-overlapping subarrays problem using prefix sums and dynamic programming. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Tree Metric Calculation](https://awesome-repositories.com/f/scientific-mathematical-computing/tree-metric-calculation.md) — Calculates tree properties like maximum path sum and diameter using recursive traversal. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))

### Software Engineering & Architecture

- [Algorithmic Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving.md) — Provides daily-updated LeetCode solutions with complexity analyses for mastering common software assessment patterns. ([source](https://cdn.jsdelivr.net/gh/sharingsource/logicstack-leetcode@main/README.md))
- [Array Manipulation Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/array-manipulation-solutions.md) — Ships a collection of array manipulation solutions for building algorithmic problem-solving skills. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A8%A1%E6%8B%9F))
- [Range Queries](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/array-manipulation-solutions/range-queries.md) — Implements segment tree and Fenwick tree solutions for range sum and XOR queries on arrays. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E7%BA%BF%E6%AE%B5%E6%A0%91))
- [Backtracking Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/backtracking-solutions.md) — Provides curated backtracking solutions with complexity analyses for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%9E%E6%BA%AF%E7%AE%97%E6%B3%95))
- [Greedy Algorithm Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/greedy-algorithm-solutions.md) — Provides curated greedy algorithm solutions with complexity analyses for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95))
- [Fast and Slow Pointer Solvers](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/josephus-problem-solving/fast-and-slow-pointer-solvers.md) — Employs two pointers moving at different speeds to detect cycles in linked lists or find middle elements. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8F%8C%E6%8C%87%E9%92%88))
- [String Manipulation Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/josephus-problem-solving/string-manipulation-solutions.md) — Provides solutions for string challenges to strengthen string-handling techniques. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A8%A1%E6%8B%9F))
- [Hash Table Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/hash-table-solutions.md) — Provides curated hash table solutions with difficulty ratings and complexity analyses for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Linear DP Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/linear-dp-solutions.md) — Walks through dynamic programming solutions for sequence-based problems with linked explanations. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E7%BA%BF%E6%80%A7-DP))
- [Two-Sum Solvers](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/partition-problem-solving/two-sum-solvers.md) — Finds two numbers in an array that add up to a target using hash-map lookups. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Multi-Number Sum Solvers](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/partition-problem-solving/two-sum-solvers/multi-number-sum-solvers.md) — Provides solutions for two-sum, three-sum, four-sum, and k-sum interview problems. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/n-%E6%95%B0%E4%B9%8B%E5%92%8C))
- [Linked List Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/linked-list-solutions.md) — Offers solutions for linked list operations to practice pointer-based data structure manipulation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A8%A1%E6%8B%9F))
- [Math and Number Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/math-and-number-solutions.md) — Delivers solutions for numerical challenges to master math-related coding patterns. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A8%A1%E6%8B%9F))
- [Math Challenge Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/math-challenge-solutions.md) — Provides step-by-step solutions to LeetCode math challenges covering number theory and geometry. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%95%B0%E5%AD%A6))
- [Sequence DP Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/sequence-dp-solutions.md) — Provides curated sequence-based DP solutions with complexity analyses for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%BA%8F%E5%88%97-DP))
- [Common Ancestor Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/common-ancestor-algorithms.md) — Implements algorithms for finding the lowest common ancestor of two nodes in binary trees. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Postfix Expression Evaluators](https://awesome-repositories.com/f/software-engineering-architecture/expression-transformers/notation-converters/postfix-expression-evaluators.md) — Evaluates postfix arithmetic expressions using a stack-based algorithm. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%A1%A8%E8%BE%BE%E5%BC%8F%E8%AE%A1%E7%AE%97))
- [Binary Search Duplicate Detectors](https://awesome-repositories.com/f/software-engineering-architecture/in-place-array-manipulations/duplicate-limiting-in-sorted-arrays/duplicate-detection-in-arrays/binary-search-duplicate-detectors.md) — Identifies a duplicate number in an array where values are in a known range using binary search on the count. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Arbitrary-Precision Arithmetic](https://awesome-repositories.com/f/software-engineering-architecture/integer-arithmetic/arbitrary-precision-arithmetic.md) — Implements arithmetic on numbers exceeding native integer limits using string or array representations. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E9%AB%98%E7%B2%BE%E5%BA%A6))
- [Next Greater Element Detection](https://awesome-repositories.com/f/software-engineering-architecture/monotone-stack-algorithms/next-greater-element-detection.md) — Implements the next greater element problem using hash maps and monotonic stack techniques. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Prefix and Suffix Product Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/prefix-and-suffix-product-algorithms.md) — Computes each element's product of all other array elements using prefix and suffix products without division. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Sliding Window Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/sliding-window-algorithms.md) — Maintains a dynamic window over a sequence to find subarrays or substrings meeting a condition, such as longest substring without repeats. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8F%8C%E6%8C%87%E9%92%88))
- [Sorted Value Frequency Counting](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/counting-sorts/sorted-value-frequency-counting.md) — Counts occurrences of a target value in a sorted array by binary searching for its range. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Missing Number Identification](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/linear-time-integer-sorts/cyclic-sorts/missing-number-identification.md) — Implements the classic missing number problem using hash sets and cyclic sort techniques. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Infinite Array Searches](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/sorted-array-searchers/standard-binary-searches/infinite-array-searches.md) — Locates a target in a sorted array of unknown length using exponential search to find bounds. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Range Update Queries](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/array-manipulation-solutions/range-queries/range-update-queries.md) — Applies a common value to every element in a contiguous subarray efficiently by recording the change at the start and end of the range. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%B7%AE%E5%88%86))
- [Single Element Locators](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/array-manipulation-solutions/single-element-locators.md) — Identifies two elements appearing once in an array using XOR and hash-map techniques. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Boundary Connectivity Analysis](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/grid-connectivity-solving/boundary-connectivity-analysis.md) — Identifies enclaves and boundary-connected regions in grid matrices using DFS. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [Multi-Source BFS Grid Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/grid-connectivity-solving/multi-source-bfs-grid-solving.md) — Solves grid distance and state propagation problems using multi-source BFS. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E5%A4%9A%E6%BA%90-BFS))
- [Heap-Based Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/heap-based-solutions.md) — Provides curated heap-based solutions with complexity analyses for technical interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%A0%86))
- [Bracket Matching Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/josephus-problem-solving/bracket-matching-solutions.md) — Provides solutions for validating and manipulating nested bracket structures using stack-based parsing. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%88))
- [Game Theory Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/josephus-problem-solving/game-theory-problem-solving.md) — Ships solutions for two-player deterministic game problems using minimax and optimal play strategies. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))
- [Queue-Based Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/josephus-problem-solving/queue-based-solutions.md) — Provides curated queue-based solutions with complexity analysis for interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E9%98%9F%E5%88%97))
- [BST](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving/partition-problem-solving/two-sum-solvers/bst.md) — Determines if two elements in a BST sum to a target value using hash set traversal. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Sorting Challenge Solutions](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/sorting-challenge-solutions.md) — Provides curated sorting solutions with complexity analyses for technical interview preparation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%8E%92%E5%BA%8F))
- [Sudoku Solvers](https://awesome-repositories.com/f/software-engineering-architecture/backtracking-algorithms/constraint-satisfaction-puzzles/sudoku-solvers.md) — Provides implementations for solving Sudoku grids using backtracking and constraint satisfaction. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%95%B0%E7%8B%AC%E9%97%AE%E9%A2%98))
- [Bidirectional Search Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/bidirectional-search-algorithms.md) — Explores graphs from both start and target simultaneously to find shortest paths faster. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-%E5%8F%8C%E5%90%91-BFS))
- [Combination Sum Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/combination-sum-algorithms.md) — Provides algorithms to find all unique sets of numbers that sum to a specific target. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8C))
- [Duplicate Element Detection](https://awesome-repositories.com/f/software-engineering-architecture/duplicate-element-detection.md) — Solves the nearby duplicate detection problem using sliding window and hash sets to find duplicates within a distance k. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Tree-Based Optimization](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/tree-based-optimization.md) — Applies dynamic programming on tree structures to compute optimal path sums and subtree properties.
- [Monotone Stack Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/monotone-stack-algorithms.md) — Uses monotonic stacks to solve next-greater-element and histogram area problems efficiently.
- [Offline Range Query Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/offline-range-query-algorithms.md) — Solves a specific LeetCode problem using offline range query techniques to process multiple interval queries efficiently. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%8E%AB%E9%98%9F%E7%AE%97%E6%B3%95))
- [Order Table Display Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/order-table-display-algorithms.md) — Solves a specific LeetCode problem using hash maps to organize restaurant order data into a table format. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Permutation Generation Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/permutation-generation-algorithms.md) — Ships algorithms for generating all possible orderings of a sequence, including handling duplicates. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/DFS))
- [Precomputed Table Lookup Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/precomputed-table-lookup-algorithms.md) — Solves a specific LeetCode problem using precomputed tables to answer queries in constant time. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%89%93%E8%A1%A8))
- [Random Matrix Flip Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/random-matrix-flip-algorithms.md) — Solves a specific LeetCode problem using hash maps to randomly flip zero cells in a binary matrix. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Random Pick from Blacklist Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/random-pick-from-blacklist-algorithms.md) — Solves a specific LeetCode problem using hash maps to randomly pick integers excluding blacklisted values. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Random Sampling](https://awesome-repositories.com/f/software-engineering-architecture/randomized-selection-algorithms/randomized-data-retrieval/random-sampling.md) — Selects a random element from a sequence when the total number of items is not known in advance, using reservoir sampling. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%93%84%E6%B0%B4%E6%B1%A0%E6%8A%BD%E6%A0%B7))
- [Weighted Random Selections](https://awesome-repositories.com/f/software-engineering-architecture/randomized-selection-algorithms/weighted-random-selections.md) — Uses prefix sums to map cumulative weights to indices, enabling random selection proportional to each element's weight. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%89%8D%E7%BC%80%E5%92%8C))
- [Prefix Sum Weighted Selectors](https://awesome-repositories.com/f/software-engineering-architecture/randomized-selection-algorithms/weighted-random-selections/prefix-sum-weighted-selectors.md) — Selects an element from a collection with probability proportional to its weight using prefix sums and binary search. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E4%BA%8C%E5%88%86))
- [Subtree Missing Gene Identifiers](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/linear-time-integer-sorts/cyclic-sorts/missing-number-identification/subtree-missing-gene-identifiers.md) — Identifies the smallest missing gene value in each subtree of a tree using DFS. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [String Hashing Techniques](https://awesome-repositories.com/f/software-engineering-architecture/string-hashing-techniques.md) — Implements methods for mapping strings to numerical values for fast identification and comparison. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C))
- [Hashing-Based Matching](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/hashing-based-matching.md) — Implements pattern matching techniques using precomputed string hashes for constant-time substring comparisons. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C))
- [Rolling Hash for DNA Sequences](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/hashing-based-matching/rolling-hash-for-dna-sequences.md) — Implements rolling hash algorithms for detecting overlapping substrings in biological DNA sequences. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Partial String Matching](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/partial-string-matching.md) — Implements algorithms for finding the best matching substring of a shorter string within a longer string. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%90%E4%B8%B2%E5%8C%B9%E9%85%8D))
- [Repetition Overlap Matches](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/repetition-overlap-matches.md) — Implements algorithms to determine the minimum number of string repetitions required to encompass another string. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%90%E4%B8%B2%E5%8C%B9%E9%85%8D))
- [Rotation Verifications](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/rotation-verifications.md) — Implements algorithms to verify if one string is a cyclic rotation of another using concatenation and hashing. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C))
- [Minimal String Rotation Search](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/string-comparisons/minimal-string-rotation-search.md) — Implements algorithms for finding the lexicographically smallest rotation of a string. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%9C%80%E5%B0%8F%E8%A1%A8%E7%A4%BA%E6%B3%95))
- [Anagram Grouping Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/anagram-grouping-algorithms.md) — Provides algorithms for clustering strings into groups based on shared character frequencies. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Longest Repeated Substring Search](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/longest-repeated-substring-search.md) — Provides algorithms for identifying the longest substring that appears at least twice in a text. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%90%8E%E7%BC%80%E6%95%B0%E7%BB%84))
- [Longest Substring Without Repeats Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/longest-substring-without-repeats-algorithms.md) — Ships algorithms for identifying the longest substring with all unique characters using hash map tracking. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Longest Valid Parentheses Identification](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting/longest-substring-identification/longest-valid-parentheses-identification.md) — Implements algorithms for finding the maximum length of a contiguous matched parentheses sequence. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%8B%AC%E5%8F%B7%E9%97%AE%E9%A2%98))
- [Substring Search Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/substring-search-algorithms.md) — Implements the strStr() function to find the first occurrence of a substring in a string. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%90%E4%B8%B2%E5%8C%B9%E9%85%8D))
- [Repeated Substring Detection](https://awesome-repositories.com/f/software-engineering-architecture/substring-search-algorithms/repeated-substring-detection.md) — Implements algorithms for identifying overlapping or non-overlapping substrings that appear multiple times. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%AD%97%E7%AC%A6%E4%B8%B2%E5%93%88%E5%B8%8C))
- [Sweep-Line Geometry Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/sweep-line-geometry-problem-solving.md) — Implements sweep-line algorithms for geometric problems like skyline and rectangle area computation. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%89%AB%E6%8F%8F%E7%BA%BF))
- [Frequent Subtree Sum Identifiers](https://awesome-repositories.com/f/software-engineering-architecture/tree-path-sum-algorithms/frequent-subtree-sum-identifiers.md) — Identifies the most frequently occurring subtree sum in a binary tree using hash maps. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%93%88%E5%B8%8C%E8%A1%A8))
- [Graph](https://awesome-repositories.com/f/software-engineering-architecture/tree-path-sum-algorithms/path-enumerations/graph.md) — Enumerates all possible paths from a start node to a target node in directed graphs using DFS. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [BFS and DFS Traversals](https://awesome-repositories.com/f/software-engineering-architecture/tree-traversal-algorithms/bfs-and-dfs-traversals.md) — Implements depth-first search for traversing graphs and trees along each branch. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%9B%BE%E8%AE%BA-DFS))
- [In-Order Iterators](https://awesome-repositories.com/f/software-engineering-architecture/tree-traversal-algorithms/in-order-iterators.md) — Traverses a BST in sorted order using an explicit stack without recursion. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91%E7%9A%84%E6%90%9C%E7%B4%A2))
- [Longest Distinct Adjacent Paths](https://awesome-repositories.com/f/software-engineering-architecture/trees/tree-node-templates/tree-based-optimization/adjacency-constrained-tree-dp/longest-distinct-adjacent-paths.md) — Solves the longest path problem in trees with distinct adjacent character constraints. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E6%A0%91))

### Artificial Intelligence & ML

- [Geometric Problem Solving](https://awesome-repositories.com/f/artificial-intelligence-ml/complex-problem-solving/geometric-problem-solving.md) — Ships solutions for computational geometry challenges including fence installation and boomerang detection. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E8%AE%A1%E7%AE%97%E5%87%A0%E4%BD%95))
- [Minimax](https://awesome-repositories.com/f/artificial-intelligence-ml/decision-trees/minimax.md) — Implements minimax search with memoization for solving two-player zero-sum games. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))
- [Optimal Play Game Solving](https://awesome-repositories.com/f/artificial-intelligence-ml/game-theory-programming/optimal-play-game-solving.md) — Ships solutions for computing optimal play outcomes in two-player turn-based games. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))

### Game Development

- [Nim Game Strategies](https://awesome-repositories.com/f/game-development/online-multiplayer/game-chat-bots/turn-based-game-bots/nim-game-strategies.md) — Implements strategies for determining winners in impartial combinatorial games like Nim. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))
- [Stone Taking Games](https://awesome-repositories.com/f/game-development/online-multiplayer/game-chat-bots/turn-based-game-bots/nim-game-strategies/stone-taking-games.md) — Models turn-based stone-picking games where players maximize scores from piles or arrays. ([source](https://github.com/SharingSource/LogicStack-LeetCode/wiki/%E5%8D%9A%E5%BC%88%E8%AE%BA))