Implement 10 Classic Algorithms with Written Complexity Analysis

Proof required

Submit: a public GitHub repository containing all five implementations with a test harness showing correctness on at least ten cases per data structure (including empty input, single-element, sorted, and reverse-sorted); a performance benchmark comparing merge sort, quicksort, and heap sort on 1,000 / 10,000 / 100,000 random integers; and a 150-word explanation of the performance results. A CS lecturer or senior engineer must confirm the implementations are correct.

What gets checked

• All five implementations are from scratch — no standard library sort or hash map used for the core algorithm
• Test harness includes edge cases — empty input, single-element, sorted, and reverse-sorted
• A CS lecturer or senior engineer has confirmed the implementations are correct

Common mistakes

• Using language built-ins (Python sorted(), Java Collections.sort()) — the proof requires implementing the algorithm, not calling it
• Test harness that only tests the happy path — edge cases are where sorting bugs hide

Resources

What a verifier looks for

• Are all implementations from scratch — no standard library algorithms used?
• Does the test harness include edge cases — empty input, single-element, sorted, reverse-sorted?
• Do benchmark results match expected complexity — merge sort and heap sort stable O(n log n), quicksort average O(n log n)?

You'll sign in first, then come straight back here.

Proof required

Submit: a public GitHub repository containing all graph algorithms and DP solutions with a test harness covering at least eight cases per algorithm (including cycles, disconnected graphs, and negative edges where applicable); and a 200-word explanation of why Bellman-Ford is necessary when Dijkstra fails, with a concrete counterexample. A CS lecturer or senior engineer must confirm the implementations are correct.

What gets checked

• All graph algorithms are from scratch — no standard library graph libraries used
• Test harness includes adversarial cases — disconnected graphs, negative cycles, and single-node graphs
• Bellman-Ford explanation includes a concrete counterexample showing Dijkstra's failure with negative edges

Common mistakes

• DP solutions that use recursion without memoisation — the proof requires DP, not brute-force recursion
• Graph test harness that only tests connected graphs without negative edges

Resources

What a verifier looks for

• Are all implementations from scratch — no graph library utilities used?
• Does the test harness include disconnected graphs, negative cycles, and single-node cases?
• Does the Bellman-Ford explanation include a concrete counterexample for Dijkstra with negative edges?

You'll sign in first, then come straight back here.

Proof required

Submit: a recording or transcript of the live technical review with a CS lecturer or senior engineer; the portfolio repository as the basis for the review; and documentation of the novel problem posed, your on-the-spot solution sketch, and the reviewer's assessment.

What gets checked

• Review was live — not a written submission with async response
• A novel problem was posed that was not in the portfolio
• Reviewer's assessment of the on-the-spot solution is documented — even if partially correct

Common mistakes

• Live review that becomes a portfolio walkthrough without a novel problem being posed
• Novel problem that is identical to one in the portfolio — must be genuinely new

Resources

What a verifier looks for

• Was the review live — not async?
• Was the novel problem genuinely not in the portfolio?
• Is the reviewer's assessment of the on-the-spot solution documented?

You'll sign in first, then come straight back here.