# OI-wiki/OI-wiki **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/oi-wiki-oi-wiki).** 25,505 stars · 4,570 forks · TypeScript ## Links - GitHub: https://github.com/OI-wiki/OI-wiki - Homepage: https://oi-wiki.org - awesome-repositories: https://awesome-repositories.com/repository/oi-wiki-oi-wiki.md ## Topics `acm-icpc` `acm-icpc-handbook` `algorithms` `competitive-programming` `data-structures` `hacktoberfest` `icpc` `icpc-handbook` `icpc-training` `oi` `oi-handbook` `oi-training` ## Description This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming. It serves as a centralized repository for algorithmic theory, data structures, and mathematical techniques, providing a structured reference for informatics and collegiate programming competitions. The project distinguishes itself by integrating educational content with a robust suite of automation utilities. It provides a complete workflow for competitive programming, including tools for automated test case generation, solution verification, and direct interaction with online judging platforms. By combining technical documentation with command-line utilities for build automation and environment management, it streamlines the entire lifecycle of developing, testing, and submitting algorithmic solutions. The knowledge base covers a broad spectrum of computational domains, including advanced dynamic programming, string processing, and number theory. It offers optimized implementations for fundamental methods and specialized algorithms, supported by infrastructure for static site generation and version-controlled content management. The documentation is rendered as a static site, ensuring consistent access to mathematical formulas and code examples across devices. ## Tags ### Development Tools & Productivity - [Competitive Programming Repositories](https://awesome-repositories.com/f/development-tools-productivity/competitive-programming-repositories.md) — Maintains a community-curated repository of algorithms, data structures, and strategies for competitive programming. - [Competitive Programming Automation Tools](https://awesome-repositories.com/f/development-tools-productivity/competitive-programming-automation-tools.md) — CLI & Automation organizes test cases and source code to automatically run and verify solutions against predefined input and output data sets. ([source](https://oi-wiki.org/tools/judger/lemon/)) - [Source Code Editors](https://awesome-repositories.com/f/development-tools-productivity/source-code-editors.md) — Provides a comprehensive environment for creating and editing C and C++ source code. ([source](https://oi-wiki.org/tools/editor/guide/)) - [Competitive Programming Tools](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/competitive-programming-tools.md) — Provides specialized utilities for parsing inputs and formatting outputs to verify algorithmic solutions in competitive programming environments. ([source](https://oi-wiki.org/tools/judger/ccr-plus/)) - [Automated Judging Validators](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/competitive-programming-tools/input-output-parsers/automated-judging-validators.md) — Compares participant output against standard solutions to determine correctness for automated judging. ([source](https://oi-wiki.org/tools/testlib/checker/)) - [Editor-Integrated Debugging](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/editor-integrated-debugging.md) — Provides integrated debugging tools to inspect program execution, breakpoints, and variable states. ([source](https://oi-wiki.org/tools/editor/codeblocks/)) - [Output Comparison Utilities](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/competitive-programming-tools/input-output-parsers/output-comparison-utilities.md) — Provides automated comparison of program outputs against reference data to verify solution correctness. ([source](https://oi-wiki.org/contest/common-tricks/)) - [Problem Package Bundlers](https://awesome-repositories.com/f/development-tools-productivity/package-deployment-automators/problem-package-bundlers.md) — Bundles problem components including source code and test data into single verifiable archives. ([source](https://oi-wiki.org/tools/polygon/)) - [Execution Engines](https://awesome-repositories.com/f/development-tools-productivity/source-code-editors/execution-engines.md) — Compiles and executes source code directly within the environment to verify algorithmic solutions. ([source](https://oi-wiki.org/tools/editor/guide/)) - [Text Editors](https://awesome-repositories.com/f/development-tools-productivity/text-editors.md) — Provides core text editing capabilities including insertion, deletion, and undo management. ([source](https://oi-wiki.org/tools/editor/vim/)) - [Evaluation Constraints](https://awesome-repositories.com/f/development-tools-productivity/cli-configurations/evaluation-constraints.md) — Defines time limits, memory constraints, and custom comparison logic for individual problems to ensure accurate scoring. ([source](https://oi-wiki.org/tools/judger/arbiter/)) - [Interactive Judging Interfaces](https://awesome-repositories.com/f/development-tools-productivity/interactive-cli-tools/interactive-judging-interfaces.md) — Enables bidirectional communication between user programs and judging systems for dynamic queries. ([source](https://oi-wiki.org/contest/problems/)) - [Search Optimization](https://awesome-repositories.com/f/development-tools-productivity/search-optimization.md) — Applies WQS binary search optimization to solve constrained dynamic programming problems efficiently. ([source](https://oi-wiki.org/dp/opt/wqs-binary-search/)) - [Syntax Highlighters](https://awesome-repositories.com/f/development-tools-productivity/syntax-highlighters.md) — Applies syntax coloring to source code to improve readability and identify structural elements. ([source](https://oi-wiki.org/tools/editor/kate/)) - [Code Formatting Tools](https://awesome-repositories.com/f/development-tools-productivity/code-quality-analysis/static-analysis-engines/static-analysis-tools/code-formatting-tools.md) — Automatically enforces consistent code indentation and styling across project files. ([source](https://oi-wiki.org/tools/editor/devcpp/)) - [Contest Workspaces](https://awesome-repositories.com/f/development-tools-productivity/contest-preparation-tools/contest-workspaces.md) — Structures contestant source code and test cases into standardized directories to enable automated evaluation. ([source](https://oi-wiki.org/tools/judger/arbiter/)) - [Formatting Enforcement Utilities](https://awesome-repositories.com/f/development-tools-productivity/output-formatting-utilities/formatting-enforcement-utilities.md) — Ensures user submissions adhere to specific formatting requirements to maintain consistency in automated evaluation. ([source](https://oi-wiki.org/tools/special-judge/)) - [Collaborative Problem Management](https://awesome-repositories.com/f/development-tools-productivity/package-deployment-automators/problem-package-bundlers/collaborative-problem-management.md) — CLI & Automation manages multi-user access permissions and resolves version conflicts to enable teams to develop programming contest problems together. ([source](https://oi-wiki.org/tools/polygon/)) - [Search-Index-Based Retrieval](https://awesome-repositories.com/f/development-tools-productivity/search-indexing-tools/search-index-based-retrieval.md) — Indexes documentation content to provide fast, client-side keyword searching across the entire knowledge base without requiring a backend server. - [Static Answer Submissions](https://awesome-repositories.com/f/development-tools-productivity/static-answer-submissions.md) — Provides pre-computed output files for specific input datasets to solve problems without requiring source code execution. ([source](https://oi-wiki.org/contest/problems/)) - [Contest Rule Standardizers](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/competitive-programming-tools/contest-rule-standardizers.md) — Standardizes contest rules and evaluation criteria to ensure fair and consistent scoring. ([source](https://oi-wiki.org/contest/icpc/)) - [Input-Output Parsers](https://awesome-repositories.com/f/development-tools-productivity/terminal-shell-cli/competitive-programming-tools/input-output-parsers.md) — Specifies variable meanings and constraints for data inputs and outputs using standardized formatting. ([source](https://oi-wiki.org/contest/problemsetting/)) ### Education & Learning Resources - [Online Judges](https://awesome-repositories.com/f/education-learning-resources/educational-resources/courses-training-certifications/interactive-learning-platforms/online-judges.md) — Automates submission, testing, and retrieval of problem data from competitive programming platforms. ([source](https://oi-wiki.org/tools/)) - [Problem Solving Guides](https://awesome-repositories.com/f/education-learning-resources/problem-solving-guides.md) — Provides a comprehensive collection of algorithmic problem-solving techniques and guides for competitive programming. ([source](https://oi-wiki.org/math/)) - [Problem Set Repositories](https://awesome-repositories.com/f/education-learning-resources/competitive-programming-training/problem-set-repositories.md) — Provides access to curated problem sets and historical contest data for competitive programming practice. ([source](https://oi-wiki.org/contest/icpc/)) - [Dynamic Programming](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/algorithmic-paradigms/dynamic-programming.md) — Implements advanced dynamic programming optimization techniques to solve complex computational problems. - [Solution Validators](https://awesome-repositories.com/f/education-learning-resources/answer-input-validation/solution-validators.md) — Implements custom checkers to verify the accuracy of algorithmic solutions against expected outputs. ([source](https://oi-wiki.org/tools/polygon/)) - [Combinatorial Constraint Solvers](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/algorithmic-paradigms/dynamic-programming/combinatorial-constraint-solvers.md) — Solves combinatorial grid constraints using dynamic programming and bitwise operations. ([source](https://oi-wiki.org/dp/state/)) - [Competitive Problem Design Frameworks](https://awesome-repositories.com/f/education-learning-resources/practice-problem-sets/competitive-problem-design-frameworks.md) — Provides guidelines and tools to create, format, and manage original problems for competitive environments. ([source](https://oi-wiki.org/contest/)) - [Problem Constraint Configurators](https://awesome-repositories.com/f/education-learning-resources/problem-constraints/problem-constraint-configurators.md) — Configures time and memory limits for programming problems to ensure consistent evaluation. ([source](https://oi-wiki.org/tools/polygon/)) - [Algorithmic Problem Solving](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving.md) — Interacts with judge systems by sending queries and reading responses to deduce hidden values. ([source](https://oi-wiki.org/contest/interaction/)) - [Competition Management Systems](https://awesome-repositories.com/f/education-learning-resources/competition-management-systems.md) — Structures competitions into progressive rounds to filter participants effectively for elite training. ([source](https://oi-wiki.org/contest/oi/)) - [Platform Interaction Utilities](https://awesome-repositories.com/f/education-learning-resources/competitive-programming-platforms/platform-interaction-utilities.md) — CLI & Automation executes common tasks on competitive programming platforms directly from the command line to streamline submission processes. ([source](https://oi-wiki.org/tools/oj-tool/)) - [Divide and Conquer Optimization](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/algorithms/algorithmic-paradigms/divide-and-conquer-algorithms/divide-and-conquer-optimization.md) — Implements divide and conquer strategies to optimize dynamic programming state transitions. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) - [Monotonicity-Based Optimization](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/technical-academic-domains/theoretical-cs-foundations/computer-science-fundamentals/mathematical-foundations/convex-optimization/monotonicity-based-optimization.md) — Applies monotonicity-based techniques like convex hulls to optimize dynamic programming state transitions. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) - [Optimal Path Reconstruction](https://awesome-repositories.com/f/education-learning-resources/dynamic-programming/optimal-path-reconstruction.md) — Enables the reconstruction of optimal solution sets by tracking state transitions during dynamic programming execution. ([source](https://oi-wiki.org/dp/knapsack/)) - [Contest Navigation Guides](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/technical-academic-domains/algorithmic-design-analysis/competitive-programming-resources/contest-navigation-guides.md) — Provides structured information on contest rules and participation to help users prepare effectively. ([source](https://oi-wiki.org/contest/)) - [Multi-Dimensional Cost Processing](https://awesome-repositories.com/f/education-learning-resources/dynamic-programming/multi-dimensional-cost-processing.md) — Provides advanced dynamic programming techniques for solving knapsack problems with multiple resource constraints. ([source](https://oi-wiki.org/dp/knapsack/)) - [Rerooting Optimization](https://awesome-repositories.com/f/education-learning-resources/dynamic-programming/rerooting-optimization.md) — Optimizes tree-based dynamic programming metrics by efficiently updating states through rerooting techniques. ([source](https://oi-wiki.org/dp/tree/)) - [Solution Count Calculation](https://awesome-repositories.com/f/education-learning-resources/dynamic-programming/solution-count-calculation.md) — Calculates the total number of valid solution paths or configurations using dynamic programming summation techniques. ([source](https://oi-wiki.org/dp/knapsack/)) - [Balanced Search Trees](https://awesome-repositories.com/f/education-learning-resources/educational-resources/algorithms-theory-academics/cs-theory-foundations/data-structure-implementations/data-structures/balanced-search-trees.md) — Implements self-balancing tree structures to support efficient insertion, deletion, and ordered retrieval. ([source](https://oi-wiki.org/lang/pb-ds/tree/)) - [Recursive Problem Solving](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/algorithmic-problem-solving/recursive-problem-solving.md) — Decomposes complex problems into simpler sub-problems to compute solutions through systematic state transitions. ([source](https://oi-wiki.org/dp/)) - [Stable Sorting Preservations](https://awesome-repositories.com/f/education-learning-resources/technical-domain-education/computer-science-education/computer-science-concepts/sorting-algorithms/stable-sorting-preservations.md) — Ensures relative order of identical items is preserved during sorting operations. ([source](https://oi-wiki.org/basic/bubble-sort/)) ### Programming Languages & Runtimes - [Algorithm Libraries](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/systems-languages/c/algorithm-libraries.md) — Ships a library of optimized implementations for fundamental algorithms and data structures used in competitive programming. - [Longest Common](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-type-utilities/subsequence-algorithms/longest-common.md) — Implements algorithms for identifying the longest common subsequence between two datasets. ([source](https://oi-wiki.org/dp/basic/)) - [Dynamic Tree Optimization](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/segment-trees/dynamic-tree-optimization.md) — Combines tree decomposition and segment trees to perform efficient dynamic programming on tree structures. ([source](https://oi-wiki.org/dp/dynamic/)) - [Queues](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/linear-collections/queues.md) — Maintains collections with efficient access to maximum or minimum values. ([source](https://oi-wiki.org/lang/pb-ds/pq/)) - [Double-Ended Queues](https://awesome-repositories.com/f/programming-languages-runtimes/double-ended-queues.md) — Implements sequence containers allowing efficient access at both ends. ([source](https://oi-wiki.org/lang/csl/sequence-container/)) - [Dynamic Strings](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings.md) — Allocates memory automatically for character sequences with built-in operators. ([source](https://oi-wiki.org/lang/csl/string/)) - [FIFO Queues](https://awesome-repositories.com/f/programming-languages-runtimes/fifo-queues.md) — Manages elements in sequences where the oldest item is accessed first. ([source](https://oi-wiki.org/lang/csl/container-adapter/)) - [Digit Range Counting](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/language-primitives/integer-range-generators/digit-range-counting.md) — Provides digit-based dynamic programming techniques for counting integers within specific ranges. ([source](https://oi-wiki.org/dp/number/)) - [LIFO Stacks](https://awesome-repositories.com/f/programming-languages-runtimes/lifo-stacks.md) — Manages elements in sequences where the most recent item is accessed first. ([source](https://oi-wiki.org/lang/csl/container-adapter/)) - [Multidimensional Arrays](https://awesome-repositories.com/f/programming-languages-runtimes/multidimensional-arrays.md) — Organizes data into nested structures for grid and matrix representation. ([source](https://oi-wiki.org/lang/array/)) - [Compile-Time Template Programming](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/programming-languages/type-systems/type-checking-disciplines/statically-typed-languages/compile-time-template-programming.md) — Implements type-safe compile-time template programming for generic algorithmic utilities. ([source](https://oi-wiki.org/lang/cpp-other-langs/)) - [Graph-Based Modeling](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/directed-acyclic-graphs/graph-based-modeling.md) — Models relational problems as directed acyclic graphs to solve them via path-finding algorithms. ([source](https://oi-wiki.org/dp/dag/)) - [Segment Tree DP Optimization](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/hierarchical-tree-structures/segment-trees/segment-tree-dp-optimization.md) — Accelerates dynamic programming state transitions by integrating segment and Fenwick trees for efficient range queries. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) - [Linked Lists](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/data-structure-type-helpers/data-structures/linear-collections/linked-lists.md) — Maintains sequences using bidirectional pointers for efficient node-based operations. ([source](https://oi-wiki.org/lang/csl/sequence-container/)) - [Randomization Algorithms](https://awesome-repositories.com/f/programming-languages-runtimes/programming-utilities/standard-libraries/standard-library-implementations/sequence-algorithms/randomization-algorithms.md) — Shuffles elements within containers or ranges using controlled random sources to ensure unbiased ordering in test datasets. ([source](https://oi-wiki.org/tools/testlib/generator/)) - [Reproducible Randomizers](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/core-conceptual-frameworks/programming-language-concepts/random-number-generation/reproducible-randomizers.md) — Produces reproducible sequences of random integers or floats based on command-line arguments for consistent test data. ([source](https://oi-wiki.org/tools/testlib/generator/)) - [Nth Element Selectors](https://awesome-repositories.com/f/programming-languages-runtimes/nth-element-selectors.md) — Rearranges sequences to identify elements at specific sorted positions. ([source](https://oi-wiki.org/basic/stl-sort/)) - [Policy-Based Structures](https://awesome-repositories.com/f/programming-languages-runtimes/policy-based-structures.md) — Provides advanced structures with extended functionality following standard library conventions. ([source](https://oi-wiki.org/lang/pb-ds/)) ### Scientific & Mathematical Computing - [Dynamic Programming Techniques](https://awesome-repositories.com/f/scientific-mathematical-computing/dynamic-programming-techniques.md) — Dynamic Programming transforms circular arrangements into linear sequences by duplicating the data structure to evaluate all possible segments. ([source](https://oi-wiki.org/dp/interval/)) - [Competitive Programming](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/development-and-practice/competitive-programming.md) — Automates the competitive programming workflow including testing, verification, and judge platform interaction. - [Linear Palindromic Substring Identification Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/string-algorithms/palindromic-sequence-analyzers/linear-palindromic-substring-identification-algorithms.md) — Implements linear-time algorithms for identifying all palindromic substrings. ([source](https://oi-wiki.org/string/manacher/)) - [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 to find the longest palindromic substring within a given string. ([source](https://oi-wiki.org/string/hash/)) - [Number Theory Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms.md) — Provides fundamental number theory algorithms including GCD, LCM, and modular arithmetic for competitive programming. ([source](https://oi-wiki.org/contest/roadmap/)) - [Divisibility Metric Calculators](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/divisibility-metric-calculators.md) — Provides fundamental divisibility metric calculators used extensively in number theory problems. ([source](https://oi-wiki.org/math/number-theory/basic/)) - [Modular Arithmetic Classes](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/modular-arithmetic-classes.md) — Provides modular arithmetic classes for efficient and safe modular operations. ([source](https://oi-wiki.org/math/number-theory/mod-arithmetic/)) - [Modular Exponentiation Solvers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/modular-exponentiation-solvers.md) — Implements efficient modular exponentiation for competitive programming. ([source](https://oi-wiki.org/math/binary-exponentiation/)) - [Mathematical Typesetting](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/mathematical-typesetting-engines/mathematical-typesetting.md) — Renders complex mathematical formulas and equations using specialized typesetting syntax for consistent documentation. ([source](https://oi-wiki.org/tools/latex/)) - [Binary Search Optimizations](https://awesome-repositories.com/f/scientific-mathematical-computing/binary-search-optimizations.md) — Dynamic Programming simplifies problems with count constraints by using binary search on the cost function when the objective is convex. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) - [Lyndon Word Decomposition Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/lyndon-word-decomposition-algorithms.md) — Provides algorithms for decomposing strings into Lyndon words. ([source](https://oi-wiki.org/string/lyndon/)) - [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) — Provides algorithms for optimizing palindrome partitioning in dynamic programming. ([source](https://oi-wiki.org/string/pam/)) - [Modular](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/modular.md) — Provides optimized modular multiplication algorithms to prevent overflow. ([source](https://oi-wiki.org/math/binary-exponentiation/)) - [Modular Multiplication Optimizers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/modular-multiplication-optimizers.md) — Provides optimized modular multiplication routines to prevent overflow in large-scale integer calculations. ([source](https://oi-wiki.org/math/number-theory/mod-arithmetic/)) - [Bitwise Manipulation Utilities](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/bitwise-manipulation-utilities.md) — Provides high-performance bitwise manipulation utilities for algorithmic processing. ([source](https://oi-wiki.org/contest/roadmap/)) - [Matrix Exponentiation Solvers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/matrix-exponentiation-solvers.md) — Implements matrix exponentiation for solving linear recurrence problems efficiently. ([source](https://oi-wiki.org/math/binary-exponentiation/)) - [Max-Plus Matrix Multiplication](https://awesome-repositories.com/f/scientific-mathematical-computing/high-performance-execution-environments/scientific-computing-platforms/scientific-computing/matrix-operations/matrix-vector-products/max-plus-matrix-multiplication.md) — Uses max-plus matrix multiplication to accelerate dynamic programming state transitions. ([source](https://oi-wiki.org/dp/dynamic/)) - [Divide and Conquer Sorts](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/algorithms-and-complexity/algorithms/sorting/divide-and-conquer-sorts.md) — Recursively splits arrays into halves and merges them back together in sorted order. ([source](https://oi-wiki.org/basic/merge-sort/)) - [Montgomery](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/montgomery.md) — Implements Montgomery modular multiplication for high-performance modular arithmetic. ([source](https://oi-wiki.org/math/number-theory/mod-arithmetic/)) - [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) — Provides efficient bitmask subset iteration techniques for state-space exploration. ([source](https://oi-wiki.org/math/binary-set/)) - [Inversion Counting Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/inversion-counting-algorithms.md) — Calculates inversion pairs in sequences to determine minimum swap counts for sorting. ([source](https://oi-wiki.org/basic/merge-sort/)) - [Modular Congruence Analyzers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/modular-congruence-analyzers.md) — Implements modular arithmetic tools essential for solving competitive programming problems involving congruences. ([source](https://oi-wiki.org/math/number-theory/basic/)) - [Modular Reduction Optimizers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/modular-reduction-optimizers.md) — Provides techniques for optimizing modular reduction operations. ([source](https://oi-wiki.org/math/number-theory/mod-arithmetic/)) - [Prime Factorization Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/prime-factorization-algorithms.md) — Provides optimized prime factorization algorithms for solving number-theoretic problems. ([source](https://oi-wiki.org/math/number-theory/basic/)) - [Expected Value Computation](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/statistics-probability/random-variables/expected-value-calculators/expected-value-computation.md) — Calculates expected values in stochastic processes using dynamic programming and linear equations. ([source](https://oi-wiki.org/dp/probability/)) - [Order Statistics](https://awesome-repositories.com/f/scientific-mathematical-computing/order-statistics.md) — Retrieves elements at specific ranks within tree structures. ([source](https://oi-wiki.org/lang/pb-ds/tree/)) - [Prefix Calculations](https://awesome-repositories.com/f/scientific-mathematical-computing/prefix-calculations.md) — Computes longest common prefixes to facilitate pattern matching and similarity analysis. ([source](https://oi-wiki.org/string/sa/)) - [Data Discretization](https://awesome-repositories.com/f/scientific-mathematical-computing/data-discretization.md) — Maps values to sorted ranks to facilitate efficient algorithmic processing. ([source](https://oi-wiki.org/lang/csl/pair/)) - [Arbitrary Precision Arithmetic](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/arbitrary-precision-arithmetic.md) — Implements arbitrary-precision integer arithmetic for handling large numbers in competitive programming. ([source](https://oi-wiki.org/contest/roadmap/)) - [Arithmetic Optimization Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/arithmetic-optimization-algorithms.md) — Implements arithmetic optimization algorithms to improve computational efficiency. ([source](https://oi-wiki.org/math/bignum/)) - [Euclidean Division Utilities](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/euclidean-division-utilities.md) — Implements Euclidean division utilities for handling modular arithmetic and remainder logic. ([source](https://oi-wiki.org/math/number-theory/basic/)) - [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 optimized implementations for binary exponentiation to solve competitive programming problems efficiently. ([source](https://oi-wiki.org/math/binary-exponentiation/)) - [Modulo Operation Optimizers](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/modulo-operation-optimizers.md) — Provides bitwise optimizations for modulo operations with powers of two. ([source](https://oi-wiki.org/math/binary-set/)) - [XOR Path Finders](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/number-theory-algorithms/xor-path-finders.md) — Provides greedy algorithms for finding maximum XOR paths in binary trees. ([source](https://oi-wiki.org/string/trie/)) - [Polynomial Multiplication Conversions](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/multiplication-algorithms/polynomial-multiplication-conversions.md) — Leverages fast transforms to convert large integer multiplication into polynomial multiplication. ([source](https://oi-wiki.org/math/bignum/)) - [Partial Range Sorters](https://awesome-repositories.com/f/scientific-mathematical-computing/partial-range-sorters.md) — Orders only the first k elements of a sequence for efficiency. ([source](https://oi-wiki.org/basic/stl-sort/)) - [Set Theory Algorithms](https://awesome-repositories.com/f/scientific-mathematical-computing/set-theory-algorithms.md) — Executes set operations like intersection and union using bitwise logic on integer-based sets. ([source](https://oi-wiki.org/math/binary-set/)) - [Nested Subset Enumerators](https://awesome-repositories.com/f/scientific-mathematical-computing/set-theory-algorithms/nested-subset-enumerators.md) — Provides efficient algorithms for nested subset enumeration. ([source](https://oi-wiki.org/math/binary-set/)) ### Software Engineering & Architecture - [Algorithmic Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving.md) — Provides a comprehensive guide to mastering algorithmic patterns, graph modeling, and problem-solving techniques for competitive programming. - [Knapsack Problem Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/knapsack-problem-solving.md) — Implements classic and advanced knapsack algorithms to solve resource allocation and optimization problems. ([source](https://oi-wiki.org/dp/knapsack/)) - [String Processing Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms.md) — Provides specialized algorithms for string processing, pattern matching, and suffix analysis. - [Acceleration Techniques](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/acceleration-techniques.md) — Provides advanced techniques like matrix exponentiation and FFT to accelerate dynamic programming solutions. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) - [Combinatorial Counting](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/combinatorial-counting.md) — Provides algorithms for counting partitions and arrangements in combinatorial problems. ([source](https://oi-wiki.org/dp/count/)) - [Memoization Caches](https://awesome-repositories.com/f/software-engineering-architecture/memoization-caches.md) — Provides memoization utilities to optimize recursive function calls and prevent redundant computations. ([source](https://oi-wiki.org/dp/memo/)) - [Monotonic Queue Optimization](https://awesome-repositories.com/f/software-engineering-architecture/queues/monotonic-queue-optimization.md) — Uses monotonic queues to efficiently query range extrema during dynamic programming state transitions. ([source](https://oi-wiki.org/dp/opt/monotonous-queue-stack/)) - [Multi-Pattern Matching Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/multi-pattern-matching-algorithms.md) — Implements algorithms for identifying multiple patterns within text simultaneously. ([source](https://oi-wiki.org/string/ac-automaton/)) - [Pattern Matching Optimization Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/pattern-matching-optimization-algorithms.md) — Provides optimized algorithms for accelerating pattern matching performance. ([source](https://oi-wiki.org/string/ac-automaton/)) - [Longest Common Substring Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/longest-common-substring-algorithms.md) — Provides algorithms for finding the longest common substring shared between strings. ([source](https://oi-wiki.org/string/general-sam/)) - [Prefix-Based Pattern Matching Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/prefix-based-pattern-matching-algorithms.md) — Provides prefix-based algorithms to optimize pattern searching performance. ([source](https://oi-wiki.org/string/match/)) - [Prefix Function Computation Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/prefix-function-computation-algorithms.md) — Implements linear-time algorithms for computing prefix functions. ([source](https://oi-wiki.org/string/kmp/)) - [Substring Counting](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/substring-counting.md) — Provides algorithms for calculating unique substring counts to solve complex string-based competitive programming problems. ([source](https://oi-wiki.org/string/sa/)) - [Suffix Array Construction](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/suffix-array-construction.md) — Implements efficient suffix array construction algorithms for rapid string pattern analysis. ([source](https://oi-wiki.org/string/sa/)) - [Z-array Value Calculation](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/z-array-value-calculation.md) — Implements Z-array calculation for linear-time pattern matching and prefix analysis. ([source](https://oi-wiki.org/string/z-func/)) - [Suffix Trees](https://awesome-repositories.com/f/software-engineering-architecture/suffix-trees.md) — Builds compressed suffix trees to enable efficient pattern matching and substring analysis. ([source](https://oi-wiki.org/string/suffix-tree/)) - [Dynamic Arrays](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-arrays.md) — Provides resizable array implementations that manage capacity and storage dynamically. ([source](https://oi-wiki.org/lang/pas-cpp/)) - [Multi-Constraint Knapsack](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/multi-constraint-knapsack.md) — Extends knapsack models to handle multiple resource constraints and hierarchical dependencies. ([source](https://oi-wiki.org/dp/knapsack/)) - [Multi-Value Hashing Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-hashing-techniques/multi-value-hashing-algorithms.md) — Provides algorithms for multi-value hash computation to improve string comparison reliability. ([source](https://oi-wiki.org/string/hash/)) - [String Matching Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms.md) — Implements efficient pattern matching algorithms using character mismatch rules. ([source](https://oi-wiki.org/string/bm/)) - [Mismatch-Allowed Matching Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/mismatch-allowed-matching-algorithms.md) — Provides algorithms for string matching that allow for a specified number of character mismatches. ([source](https://oi-wiki.org/string/hash/)) - [Minimal Cyclic Shift Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/minimal-cyclic-shift-algorithms.md) — Implements algorithms to find the lexicographically smallest cyclic shift of a string. ([source](https://oi-wiki.org/string/minimal-string/)) - [Pattern Occurrence Location Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/pattern-occurrence-location-algorithms.md) — Provides algorithms for locating all occurrences of patterns within text. ([source](https://oi-wiki.org/string/z-func/)) - [Prefix Occurrence Counting Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/prefix-occurrence-counting-algorithms.md) — Provides algorithms for counting prefix occurrences within strings. ([source](https://oi-wiki.org/string/kmp/)) - [Repetitive String Compression Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/repetitive-string-compression-algorithms.md) — Implements algorithms for compressing repetitive string patterns. ([source](https://oi-wiki.org/string/main-lorentz/)) - [Shortest Missing Substring Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/shortest-missing-substring-algorithms.md) — Provides algorithms for identifying the shortest missing substring within text. ([source](https://oi-wiki.org/string/sam/)) - [Suffix Balanced Trees](https://awesome-repositories.com/f/software-engineering-architecture/suffix-balanced-trees.md) — Maintains lexicographical order of string suffixes using balanced tree structures for efficient retrieval. ([source](https://oi-wiki.org/string/suffix-bst/)) - [Suffix Array Generation](https://awesome-repositories.com/f/software-engineering-architecture/suffix-balanced-trees/suffix-array-generation.md) — Provides utilities to generate sorted suffix arrays from balanced tree structures. ([source](https://oi-wiki.org/string/suffix-bst/)) - [Grid Connectivity Solving](https://awesome-repositories.com/f/software-engineering-architecture/algorithmic-problem-solving/grid-connectivity-solving.md) — Implements plug-based dynamic programming to solve complex grid connectivity and tiling problems. ([source](https://oi-wiki.org/dp/plug/)) - [Output Validators](https://awesome-repositories.com/f/software-engineering-architecture/middleware/custom-middleware-implementations/output-validators.md) — Verifies non-standard output formats by comparing results against expected answers using specialized logic. ([source](https://oi-wiki.org/tools/judger/arbiter/)) - [Bucket Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/bucket-sorts.md) — Organizes elements into multiple containers based on their values and sorts each container individually. ([source](https://oi-wiki.org/basic/bucket-sort/)) - [Counting Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/counting-sorts.md) — Arranges integers by counting the frequency of each value and calculating their relative positions. ([source](https://oi-wiki.org/basic/counting-sort/)) - [Merge Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/merge-sorts.md) — Implements merge sort for efficient sequence ordering. ([source](https://oi-wiki.org/basic/merge-sort/)) - [String Hashing Techniques](https://awesome-repositories.com/f/software-engineering-architecture/string-hashing-techniques.md) — Enables constant-time substring hash queries using prefix hashing. ([source](https://oi-wiki.org/string/hash/)) - [Hashing-Based Matching](https://awesome-repositories.com/f/software-engineering-architecture/string-matching-algorithms/hashing-based-matching.md) — Implements hash-based string matching for efficient pattern identification. ([source](https://oi-wiki.org/string/hash/)) - [Occurrence Searching](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/occurrence-searching.md) — Searches for pattern occurrences and determines maximum prefix lengths. ([source](https://oi-wiki.org/string/sam/)) - [Tandem Repetition Identification](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/tandem-repetition-identification.md) — Identifies tandem repetitions in strings using efficient divide-and-conquer algorithms. ([source](https://oi-wiki.org/string/main-lorentz/)) - [Suffix Automata](https://awesome-repositories.com/f/software-engineering-architecture/suffix-automata.md) — Constructs suffix automata to efficiently process and query multiple strings simultaneously. ([source](https://oi-wiki.org/string/general-sam/)) - [In-Place Suffix Sorts](https://awesome-repositories.com/f/software-engineering-architecture/suffix-trees/in-place-suffix-sorts.md) — Implements in-place suffix sorting algorithms for efficient string processing. ([source](https://oi-wiki.org/string/sa-optimal-inplace/)) - [Memory Optimization Strategies](https://awesome-repositories.com/f/software-engineering-architecture/suffix-trees/in-place-suffix-sorts/memory-optimization-strategies.md) — Optimizes memory usage during suffix sorting using divide-and-conquer strategies. ([source](https://oi-wiki.org/string/sa-optimal-inplace/)) - [Cyclic Dependency Resolution](https://awesome-repositories.com/f/software-engineering-architecture/dependency-resolution-engines/circular-dependency-resolution/cyclic-dependency-resolution.md) — Implements methods to resolve circular state dependencies using linear equation systems. ([source](https://oi-wiki.org/dp/probability/)) - [Dual Optimization](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/dual-optimization.md) — Implements dual optimization methods to solve constrained dynamic programming problems. ([source](https://oi-wiki.org/dp/opt/wqs-binary-search/)) - [Grouping Decision Optimization](https://awesome-repositories.com/f/software-engineering-architecture/dynamic-programming/grouping-decision-optimization.md) — Optimizes task partitioning sequences using dynamic programming to satisfy weight and time constraints. ([source](https://oi-wiki.org/dp/state/)) - [Query Strategy Optimizers](https://awesome-repositories.com/f/software-engineering-architecture/query-optimization/query-strategy-optimizers.md) — Minimizes the number of operations by using techniques like random sampling or binary search. ([source](https://oi-wiki.org/contest/interaction/)) - [Heap Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/heap-sorts.md) — Implements heap sort algorithms for efficient element ordering. ([source](https://oi-wiki.org/basic/heap-sort/)) - [Hybrid Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/hybrid-sorts.md) — Provides hybrid sorting implementations to optimize performance on partially sorted datasets. ([source](https://oi-wiki.org/basic/tim-sort/)) - [Insertion Sorts](https://awesome-repositories.com/f/software-engineering-architecture/sorting-algorithms/insertion-sorts.md) — Implements insertion sort for iterative element ordering. ([source](https://oi-wiki.org/basic/insertion-sort/)) - [Automata Construction](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/automata-construction.md) — Implements finite state machine construction for accelerated pattern matching. ([source](https://oi-wiki.org/string/kmp/)) - [Cyclic Shift Algorithms](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/cyclic-shift-algorithms.md) — Provides efficient algorithms for finding the smallest cyclic shift of a string. ([source](https://oi-wiki.org/string/lyndon/)) - [Dynamic String Updates](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/dynamic-string-updates.md) — Provides algorithms for dynamic string updates using balanced trees. ([source](https://oi-wiki.org/string/suffix-bst/)) - [Lexicographical Substring Searches](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/lexicographical-substring-searches.md) — Provides algorithms for finding substrings by lexicographical rank. ([source](https://oi-wiki.org/string/sam/)) - [Occurrence Analysis](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/occurrence-analysis.md) — Analyzes substring occurrences using suffix tree traversal. ([source](https://oi-wiki.org/string/suffix-tree/)) - [Pattern Analysis](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/pattern-analysis.md) — Analyzes string patterns including prefixes and palindromes. ([source](https://oi-wiki.org/string/)) - [Range Query Optimization](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/range-query-optimization.md) — Optimizes range-based string queries using segment trees and monotonic stacks. ([source](https://oi-wiki.org/string/sa/)) - [Subsequence Validation](https://awesome-repositories.com/f/software-engineering-architecture/string-processing-algorithms/subsequence-validation.md) — Validates subsequence membership using state machine tracking. ([source](https://oi-wiki.org/string/seq-automaton/)) - [Occurrence Counting](https://awesome-repositories.com/f/software-engineering-architecture/suffix-balanced-trees/occurrence-counting.md) — Counts substring occurrences using balanced suffix tree queries. ([source](https://oi-wiki.org/string/pam/)) - [Position Location](https://awesome-repositories.com/f/software-engineering-architecture/suffix-trees/position-location.md) — Locates pattern positions by traversing suffix link trees. ([source](https://oi-wiki.org/string/sam/)) - [Tree-Based Knapsack](https://awesome-repositories.com/f/software-engineering-architecture/tree-traversal-algorithms/tree-based-knapsack.md) — Solves knapsack problems on hierarchical structures by combining tree traversal with subset optimization. ([source](https://oi-wiki.org/dp/tree/)) - [Tree-Based Optimization](https://awesome-repositories.com/f/software-engineering-architecture/trees/tree-node-templates/tree-based-optimization.md) — Aggregates optimal values across tree structures using depth-first search techniques for dynamic programming. ([source](https://oi-wiki.org/dp/tree/)) ### Testing & Quality Assurance - [Algorithmic Validation Tools](https://awesome-repositories.com/f/testing-quality-assurance/validation-verification/input-validation/algorithmic-validation-tools.md) — Implements automated black-box testing to verify algorithmic solutions against predefined input and output datasets. ([source](https://oi-wiki.org/contest/problems/)) - [Test Case Generators](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/test-execution-orchestration/test-case-generators.md) — Generates diverse test datasets, including random permutations, for consistent algorithmic verification. ([source](https://oi-wiki.org/contest/problemsetting/)) - [Stress Testing](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/automated-test-generators/stress-testing.md) — Runs automated comparisons between multiple solution implementations to identify logic errors and generate counter-examples. ([source](https://oi-wiki.org/tools/polygon/)) - [Batch Execution Runners](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-execution-runners/cli-test-runners/batch-execution-runners.md) — CLI & Automation scores submissions based on test cases processed after a session ends to simulate traditional exam conditions. ([source](https://oi-wiki.org/contest/oi/)) - [Competitive Code Hacking Tools](https://awesome-repositories.com/f/testing-quality-assurance/competitive-code-hacking-tools.md) — CLI & Automation submits custom test cases to verify the correctness of other solutions after locking code to identify potential flaws. ([source](https://oi-wiki.org/contest/oi/)) - [CLI Test Runners](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-execution-runners/cli-test-runners.md) — Manages real-time communication between contestant programs and judges by streaming inputs and outputs. ([source](https://oi-wiki.org/tools/testlib/interactor/)) - [Partial Data Test Runners](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-execution-runners/cli-test-runners/partial-data-test-runners.md) — Verifies solutions against a subset of data to balance immediate feedback with performance analysis. ([source](https://oi-wiki.org/contest/oi/)) - [Grading Systems](https://awesome-repositories.com/f/testing-quality-assurance/code-quality-review/automated-code-review/grading-systems.md) — Automates the execution of participant code against test datasets to generate performance results and scores. ([source](https://oi-wiki.org/tools/judger/arbiter/)) - [Test Output Redirectors](https://awesome-repositories.com/f/testing-quality-assurance/general-testing-utilities/test-utilities-assertions/browser-ui-interaction/component-interaction-testing/file-upload-testing-utilities/test-output-redirectors.md) — Automates the generation of multiple distinct test cases by redirecting output streams to indexed files. ([source](https://oi-wiki.org/tools/testlib/generator/)) - [Test Program Registrars](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/testing-frameworks/test-frameworks/execution-and-infrastructure/test-execution-runners/cli-test-runners/test-program-registrars.md) — Initializes and registers testing scripts to handle specific roles within competitive programming pipelines. ([source](https://oi-wiki.org/tools/testlib/general/)) ### Business & Productivity Software - [Contest Scheduling Utilities](https://awesome-repositories.com/f/business-productivity-software/scheduling-automation/contest-scheduling-utilities.md) — Organizes seasonal contests and qualification rounds to facilitate structured skill development. ([source](https://oi-wiki.org/contest/icpc/)) ### Content Management & Publishing - [Version-Controlled Knowledge Bases](https://awesome-repositories.com/f/content-management-publishing/content-management-systems/content-architecture-modeling/document-architectures/version-controlled-knowledge-bases.md) — Maintains a version-controlled knowledge base of algorithmic theory and documentation to ensure historical integrity and collaborative updates. - [Static Site Generation](https://awesome-repositories.com/f/content-management-publishing/static-site-document-generators/static-site-generators/static-site-generation.md) — Generates a collection of static HTML pages from structured documentation files to ensure fast loading and high availability. - [Markdown-Based Content Authoring](https://awesome-repositories.com/f/content-management-publishing/content-management-systems/content-authoring-tools/markdown-based-content-authoring/markdown-based-content-authoring.md) — Uses a lightweight markup language to manage technical documentation, enabling version control and collaborative editing of algorithmic content. ### Data & Databases - [Collection Iterators](https://awesome-repositories.com/f/data-databases/collection-iterators.md) — Provides standard interfaces for traversing custom data structures and collections efficiently. ([source](https://oi-wiki.org/lang/csl/iterator/)) - [Priority Queues](https://awesome-repositories.com/f/data-databases/data-structure-implementations/optimized-data-structures/priority-queues.md) — Data Structures maintain ordered pairs of values to efficiently manage state in graph traversal algorithms like Dijkstra. ([source](https://oi-wiki.org/lang/csl/pair/)) - [Heuristic Pattern Search Algorithms](https://awesome-repositories.com/f/data-databases/string-data-structures/search-utilities/heuristic-pattern-search-algorithms.md) — Implements heuristic-based algorithms to optimize pattern search performance. ([source](https://oi-wiki.org/string/bm/)) - [Custom Output Checkers](https://awesome-repositories.com/f/data-databases/data-serialization-formats/output-formatting-systems/custom-output-checkers.md) — Implements custom checkers to evaluate non-standard or floating-point answers in automated judging. ([source](https://oi-wiki.org/contest/problemsetting/)) - [Graph Data Models](https://awesome-repositories.com/f/data-databases/graph-data-models.md) — Represents complex connections between entities using nodes and edges. ([source](https://oi-wiki.org/graph/)) - [Hash Tables](https://awesome-repositories.com/f/data-databases/hash-tables.md) — Organizes elements using hash tables for constant-time lookup and insertion. ([source](https://oi-wiki.org/lang/csl/unordered-container/)) - [Key-Value](https://awesome-repositories.com/f/data-databases/storage-engines/key-value.md) — Associates unique keys with values for efficient lookup and retrieval. ([source](https://oi-wiki.org/lang/csl/associative-container/)) - [Online Suffix Array Search Algorithms](https://awesome-repositories.com/f/data-databases/string-data-structures/search-utilities/online-suffix-array-search-algorithms.md) — Implements online substring searching using pre-indexed suffix arrays. ([source](https://oi-wiki.org/string/sa/)) - [Pattern Occurrence Identification Algorithms](https://awesome-repositories.com/f/data-databases/text-pattern-matching/pattern-occurrence-identification-algorithms.md) — Implements algorithms for identifying pattern occurrences within text. ([source](https://oi-wiki.org/string/match/)) - [K-th Best Solution Identification](https://awesome-repositories.com/f/data-databases/k-nearest-neighbor-retrieval/k-th-best-solution-identification.md) — Identifies the k-th optimal solution by maintaining ordered sequences of values within dynamic programming states. ([source](https://oi-wiki.org/dp/knapsack/)) - [Efficient Array Partitioning](https://awesome-repositories.com/f/data-databases/partitioning-algorithms/efficient-array-partitioning.md) — Organizes elements by recursively partitioning a sequence around a pivot value to ensure sub-sequences are ordered. ([source](https://oi-wiki.org/basic/quick-sort/)) ### System Administration & Monitoring - [Algorithmic Resource Limiters](https://awesome-repositories.com/f/system-administration-monitoring/resource-constraints/algorithmic-resource-limiters.md) — Establishes time and memory constraints based on reference solution performance to filter out inefficient algorithms. ([source](https://oi-wiki.org/contest/problemsetting/)) ### Artificial Intelligence & ML - [Interval Optimization](https://awesome-repositories.com/f/artificial-intelligence-ml/detection-confidence-metrics/confidence-interval-calculators/interval-optimization.md) — Provides interval-based dynamic programming solutions for sequence optimization problems. ([source](https://oi-wiki.org/dp/interval/)) ### Networking & Communication - [Real-time Evaluation Feedback](https://awesome-repositories.com/f/networking-communication/real-time-communication/real-time-evaluation-feedback.md) — Returns evaluation results immediately upon submission to facilitate iterative learning. ([source](https://oi-wiki.org/contest/oi/)) ### Web Development - [Doubling State Transitions](https://awesome-repositories.com/f/web-development/frontend-development-tools/state-data-management/state-logic-patterns/state-transition-controllers/doubling-state-transitions.md) — Uses binary lifting techniques to achieve logarithmic time complexity in state transitions. ([source](https://oi-wiki.org/dp/opt/dp-opt/)) ### User Interface & Experience - [Deterministic Pivot Selections](https://awesome-repositories.com/f/user-interface-experience/programmatic-selection/deterministic-pivot-selections.md) — Selects pivot values using the median-of-medians approach to ensure linear time complexity. ([source](https://oi-wiki.org/basic/quick-sort/))