The DMOJ judge-server is the core judging component of the DMOJ (Modern Online Judge) platform, responsible for executing and evaluating programming contest submissions in sandboxed environments. It features a plugin-based architecture supporting over 50 programming languages through language-specific executors, graders, and checkers. The system handles secure sandboxing via ptrace and seccomp (Linux) or ptrace (FreeBSD), manages problem configurations with automatic reloading, and communicates with the judge server using a custom packet protocol. Key entry points include the main judge daemon (dmoj), a CLI tool for local testing (dmoj-cli), and an autoconfiguration utility for runtime detection. The codebase demonstrates strong separation of concerns, with isolated components for sandboxing, subprocess communication, and output normalization that exhibit reusable patterns.
EndlessCheng/codeforces-go is a comprehensive collection of competitive programming solutions and algorithm templates written in Go. The repository provides reusable implementations of data structures (e.g., segment trees, fenwick trees, treaps, suffix automata) and algorithms (e.g., Aho-Corasick, various math functions) in the copypasta directory. It also includes a test harness (main/testutil) for verifying solutions against sample inputs and outputs, along with code generators to automate test file creation. Each solution is typically a standalone Go program that reads from standard input and writes to standard output, following the typical format for online judge submissions. The repository is organized by problem source (LeetCode, Codeforces, AtCoder, etc.) and difficulty, making it a valuable reference for learning and practicing competitive programming.
This repository is a comprehensive, educational library of data structures and algorithms implemented in Python 3. It is organized into subpackages by algorithmic category (sorting, searching, graph, dynamic programming, backtracking, bit manipulation, string, tree, math, matrix, compression, streaming, etc.), each containing self-contained modules with clear function signatures, docstrings, complexity analysis, and often multiple implementation variants. The library is installable via pip and intended for learning, reference, and reuse in competitive programming or software development. It is not an application or data pipeline; it has no web server, CLI entry point, or external runtime dependencies beyond the Python standard library. The architecture is a flat library with a shared `algorithms/common` module providing reusable data types (`TreeNode`, `ListNode`, `Graph`) and each subpackage re-exporting its public API through `__init__.py` files. The codebase demonstrates a mix of modern and legacy Python styles, with newer modules using type hints, dataclasses, and doctests, while older modules rely on bare comments and local node definitions. Despite some inconsistencies and minor bugs, the repository is a well-structured, actively maintained collection that serves as a valuable reference for algorithm implementations.
OI-Wiki is a comprehensive, open-source knowledge base for competitive programming (Olympiad in Informatics, ICPC). It is primarily a static documentation site built with MkDocs, featuring thousands of pages covering algorithms, data structures, mathematics, and programming language tools. The codebase includes thousands of standalone C++/Python/Java code examples, each accompanied by test input/output files, which serve as verified implementations for educational purposes. While not a running application, the repository contains a sophisticated build pipeline (pre-build scripts, post-build HTML processing, custom linting) and extensive CI/CD workflows for testing code correctness and documentation quality. The architecture is that of a content management system with heavy emphasis on reproducible, modular examples. Its primary value lies in the curated collection of reusable algorithm templates and the infrastructure ensuring they remain correct across platforms.
Another Graph Editor is an interactive web application for visualizing and manipulating graphs, designed with competitive programming in mind. Built with React, TypeScript, Tailwind CSS, and HTML Canvas, it allows users to input graphs in various formats (edge lists, parent-child arrays, Leetcode-style) and visualize them with multiple layout options (force-directed, tree, bipartite, grid). The application implements numerous graph algorithms for visualization including connected components, bridges and cut vertices, biconnected components, and minimum spanning trees. Users can interact with the graph through drawing, coloring, and node/edge manipulation, with support for multiple test cases and export to PNG/SVG formats.
This repository is a collection of competitive programming solutions and learning resources accumulated during interview preparation for a Microsoft SWE role. It contains implementations of algorithms and data structures from platforms like LeetCode, HackerRank, CodeChef, and others, organized by problem source and topic. The repository serves as both a personal record of solved problems and a reference for common coding interview patterns. The codebase consists of standalone solution files that implement specific algorithms to solve well-defined problems. Rather than a unified application, it's an educational repository where each file represents a self-contained solution to a particular coding challenge. The solutions demonstrate various techniques including two-pointer approaches, stack-based algorithms, in-place array modifications, and thread synchronization patterns. While the repository doesn't contain a single cohesive software system, it does include several reusable algorithmic patterns that could be extracted for use in other projects. Notable examples include the stack-based parentheses validation, two-pointer technique for sorted arrays, in-place array modification algorithms, and thread coordination mechanisms using Events and Semaphores. These components represent fundamental computer science concepts implemented with attention to correctness and efficiency.
This repository is a comprehensive educational collection of algorithm problem solutions for LeetCode and Kamacoder (ACM mode), organized as a structured learning path for interview preparation. It contains over 350 Markdown files, each providing a detailed explanation, multiple solution approaches, and code in C++, Java, Python, Go, JavaScript, and many other languages. The content is purely pedagogical and static—not a runnable application or a data pipeline. It serves as the online companion to the '代码随想录' (programmercarl.com) book and video series. The repository demonstrates high consistency in formatting and pedagogical templates, but it is not software engineering; the 'craftsmanship' lies in the educational structure rather than in software architecture. It is hybrid in the sense that some files include empirical complexity analysis, but the dominant character is an educational resource.
This repository is a massive, multi-language collection of algorithmic problem solutions primarily from LeetCode, 剑指Offer (Sword to Offer), and Cracking the Coding Interview. It serves as a reference and study resource for coding interview preparation. The core content is organized by problem number and includes solutions in over 10 languages (Python, Java, C++, Go, TypeScript, Rust, etc.). A secondary component is a web application (Dockerfile, package.json) that likely powers the site at leetcode.doocs.org, providing a browsable interface for the solutions. The repository is actively maintained with frequent commits and a large contributor base, but the codebase is dominated by boilerplate solution files with high duplication and no automated testing. The architecture is a flat collection of independent solution files rather than a cohesive software application.
This repository is a comprehensive collection of C++ solutions to LeetCode and competitive programming problems, organized by data structure and algorithm topic (e.g., Arrays, DP, Graph, Tree, Sliding Window, etc.). It serves as a study resource for interview preparation and algorithm practice. The codebase consists of standalone solution files, each solving a specific problem, with no shared library or build system. While the solutions are functional and cover a wide range of topics, they are tightly coupled to individual problem statements and lack modularity or test coverage, limiting reusability as independent components. The repository is actively maintained with frequent additions of new solutions.
This repository is a large, personal competitive programming solution archive spanning multiple platforms (LeetCode, Codeforces, CSES, AtCoder, etc.) with a companion Next.js web application (LeetGoat) for managing and browsing problems. The codebase contains over 3,900 files, predominantly short algorithmic solution scripts in Python, C++, and JavaScript, accompanied by reusable algorithm templates and a structured problem metadata system using Prisma and Supabase. While the primary content is the solution library, the integrated web application provides authentication, admin CRUD for problems and tags, drill grouping, and practice pages. The app uses tRPC for type-safe APIs, Supabase for auth, and Prisma for database access. However, many site pages are placeholders ("Coming Soon"), indicating an early-stage product. Code quality varies widely: many solutions are well-commented and demonstrate strong algorithmic thinking (DP, segment trees, graph algorithms), while others are incomplete, contain known bugs, or carry disclaimers like "BAD SOLUTION". The templates directory contains genuinely reusable components (sparse tables, DSU, segment trees, centroid decomposition) that could be extracted for other projects. Maintenance is ongoing with frequent commit activity, but the sheer volume and mixed concerns (solutions + web app) introduce technical drift. No testing suite or CI is evident, and some solutions depend on external libraries (sortedcontainers) not always available in competitive programming environments.
This repository is a large, multi-language algorithm reference library with an interactive web frontend for visualizations. It contains over 247 classic algorithms (sorting, graph, DP, math, strings, geometry, cryptography, etc.) implemented in 11 languages (Python, Java, C++, C, Go, TypeScript, Kotlin, Rust, Swift, Scala, C#). The web application, built with React and TypeScript, provides a browsable catalog, progress tracking, and step-by-step algorithm visualizations. The codebase follows a consistent pattern where most algorithm functions accept a flat integer array as input and return a single integer or array, enabling uniform testing and frontend consumption. While the repository is comprehensive and well-organized at a high level, the quality of individual implementations varies significantly. Some files contain bugs (e.g., mislabeled algorithms, incorrect logic), hardcoded limits, or outdated practices (e.g., conio.h, Python 2 syntax). Duplicate implementations across languages and within the same language increase maintenance burden. The web frontend is modern and well-structured, with reusable components like the visualization registry and progress context. The scaffolding and validation scripts demonstrate good engineering practices for maintaining such a large collection. Overall, this is a valuable educational resource and reference for algorithm implementations across multiple languages, but it is not production-grade software. The codebase is actively maintained with CI workflows and issue templates, but the sheer scale and language sprawl introduce technical drift and inconsistency. It is best suited for learning, competitive programming preparation, and as a starting point for algorithm visualizations.
This repository is a curated collection of code implementations, cheat sheets, and study resources for software engineering (SDE) interview preparation. It contains hundreds of independently written C++, Python, and C files covering fundamental data structures (arrays, linked lists, stacks, queues, trees, graphs) and algorithms (sorting, searching, dynamic programming, greedy, backtracking, string algorithms, etc.). The repo also includes problem sheets from popular SDE preparation resources (Striver's SDE Sheet, Love Babbar DSA Sheet), competitive programming patterns, and notes on core subjects like DBMS, OS, and CN. It is primarily a reference/learning resource rather than a cohesive application or data pipeline; the code is not packaged as a library and lacks tests, build systems, or dependency management. Many files are standalone textbook-style implementations. While the breadth is impressive, the depth and consistency of quality vary significantly across contributions, and the repository appears to be in a stale maintenance state with no recent meaningful code updates.
The DSA-KIT repository is a static resource curation project containing no executable code or data processing pipelines. It functions as a comprehensive reference guide for Data Structures and Algorithms learning, organized entirely within a single README.md file that categorizes external links to books, courses, problem sets, visualization tools, and practice platforms by topic and difficulty level. The repository does not ingest, transform, or analyze any data; instead, it serves as a manually maintained directory of third-party educational resources. From a data engineering perspective, the project represents a flat-file dataset of resource metadata (titles, URLs, descriptions) structured using Markdown syntax. There is no ETL pipeline, automation, or validation logic—the curation relies entirely on manual updates by the maintainer. The architecture lacks separation of concerns, with all content (resource listings, categorization, and presentation) coupled in one file. While the resource organization follows a logical taxonomy (e.g., grouping by data structure type or learning objective), it demonstrates no novel data engineering patterns or reusable components. The repository shows signs of active maintenance with a recent commit (2026-03-18), but exhibits significant reproducibility risks due to its dependence on external links that may become inaccessible over time. There are no mechanisms for link validation, dependency tracking, or environment isolation. The core dataset (the list of links) is version-controlled and reproducible via cloning, but the practical utility decays as external resources change or disappear. Despite its popularity (537 stars, 72 forks), the project lacks the automation, scalability, and resilience expected of professional data engineering artifacts.