Tri-Language Algorithmic Testing Infrastructure

High-performance algorithmic testing architecture. Engineered for strict mathematical analysis and microsecond execution across TypeScript, Python, and Java.

1. Algorithm Ingestion: Document mathematical theory and resource complexities in the local README.md.
2. Implementation Architecture:
   • Write TypeScript in index.ts.
   • Write Python in main.py.
   • Write Java in [AlgorithmName].java.
3. Validation Protocol:
   • Engineer comprehensive boundary conditions in cases.json.
   • All three runtime environments consume the exact same validation sets. This enforces strict parity.

We enforce rigid namespace isolation. All domains exist at the root level to prevent testing logic from bleeding across environments.

algorithms/                 # Pure functions, mathematical theory
├── 01-linear-search/
│   ├── README.md           # Theory, Time/Space complexities
│   ├── index.ts            # TS Implementation
│   ├── main.py             # Python Implementation
│   ├── LinearSearch.java   # Java Implementation
│   └── __tests__/          # Isolated test harnesses and cases.json

data-structures/            # Memory layouts, object primitives
├── pure-theory/            # Markdown documentation (e.g., arrays.md)
├── 01-min-heap/            # Tri-language implementations
│   └── ...

problems/                   # Applied problems referencing core algorithms
├── 01-first-and-last-pos/
│   └── ...

Audit your algorithms across the tri-language infrastructure. Execute these commands from the root directory to validate logic.

Target a specific algorithm or problem directory. Replace the trailing path with your active module.

• TypeScript: bun test .\algorithms\01-linear-search\
• Python: uv run pytest .\algorithms\01-linear-search\
• Java: .\test-java.ps1 .\algorithms\01-linear-search\

Validate the entire codebase architecture simultaneously.

• TypeScript: bun test
• Python: uv run pytest .
• Java: Global execution pipeline requires module-specific targeting. Audit individual modules using the isolated script above.

Our index is partitioned strictly by domain. Pure theory dictates the concept. Implementations dictate the exact Big-O bounding.

Fundamental memory layouts, primitives, and computer science concepts.

Tri-language implementations of memory structures.

Pure mathematical algorithms operating on structures.

Real-world applications mapped directly to core algorithms.