coop/rose-ash
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
6d89da9380b91f792ff93aae2fd678c18d80c1dc
rose-ash/lib/ocaml/baseline
History
giles 6d89da9380
Some checks failed
Test, Build, and Deploy / test-build-deploy (push) Failing after 24s
Details
ocaml: phase 5.1 interval_overlap.ml baseline (7 intervals, 6 overlapping pairs) 
For each (i, j) pair with i < j, test whether intervals (s1, e1)
and (s2, e2) overlap via the standard `s1 <= e2 && s2 <= e1`.

  intervals: (1,4) (2,5) (7,9) (3,6) (8,10) (11,12) (0,2)

  overlapping pairs:
    (1,4) & (2,5)        (1,4) & (3,6)        (1,4) & (0,2)
    (2,5) & (3,6)        (2,5) & (0,2)
    (7,9) & (8,10)
                                                     = 6

Tests double for-loop with both-side tuple destructure via
`let (s1, e1) = arr.(i) in`, conjunctive comparison, list-to-
array conversion.

188 baseline programs total.
2026-05-11 03:24:45 +00:00
..
abundant.ml
ocaml: phase 5.1 abundant.ml baseline (count abundant numbers < 100 = 21)
2026-05-10 00:36:29 +00:00
ackermann.ml
ocaml: phase 5.1 ackermann.ml baseline (ack(3, 4) = 125)
2026-05-09 08:50:12 +00:00
adler32.ml
ocaml: phase 5.1 adler32.ml baseline (Adler-32 of 'Wikipedia' = 300286872 = 0x11E60398)
2026-05-09 19:18:01 +00:00
anagram_check.ml
ocaml: phase 5.1 anagram_check.ml baseline (char-frequency array, 2/4 anagrams)
2026-05-09 12:14:32 +00:00
anagram_groups.ml
ocaml: phase 5.1 anagram_groups.ml baseline (group by canonical anagram, 3 groups)
2026-05-09 19:47:21 +00:00
anagrams.ml
ocaml: phase 5.1 anagrams.ml baseline (18/18 pass)
2026-05-08 19:57:09 +00:00
atm.ml
ocaml: phase 5.1 atm.ml baseline (mutable record + exception + try/with, balance = 120)
2026-05-09 12:34:36 +00:00
bag.ml
ocaml: phase 5.1 bag.ml baseline + String.equal/compare/cat/empty (+3 tests, 579 total)
2026-05-09 06:15:03 +00:00
balance.ml
ocaml: phase 5.1 balance.ml baseline (paren/bracket/brace balance via Stack)
2026-05-09 06:59:22 +00:00
base_n.ml
ocaml: phase 5.1 base_n.ml baseline (int to base-N string, length sum = 17)
2026-05-09 12:52:55 +00:00
bf_full.ml
ocaml: phase 5.1 bf_full.ml baseline (full Brainfuck with [] loops, +++[.-] = 6)
2026-05-09 12:24:48 +00:00
bfs_grid.ml
ocaml: && / || short-circuit fix + bfs_grid.ml baseline (5x5 grid, dist 8)
2026-05-10 21:37:41 +00:00
bfs.ml
ocaml: phase 5.1 bfs.ml baseline (20/20 pass)
2026-05-08 21:05:32 +00:00
bigint_add.ml
ocaml: phase 5.1 bigint_add.ml baseline (digit-list bignum add, 1+18+9 = 28)
2026-05-09 11:19:23 +00:00
binary_heap.ml
ocaml: phase 5.1 binary_heap.ml baseline (min-heap sort 9 vals -> 123456789)
2026-05-10 06:43:46 +00:00
bipartite.ml
ocaml: phase 5.1 bipartite.ml baseline (7-node bipartite, 4 in color 0)
2026-05-10 23:08:16 +00:00
bisect.ml
ocaml: phase 5.1 bisect.ml baseline (root-finding, sqrt(2)*100 = 141)
2026-05-09 13:02:17 +00:00
bits.ml
ocaml: phase 4 bitwise ops land/lor/lxor/lsl/lsr/asr + bits.ml baseline (+5 tests, 607 total)
2026-05-09 09:15:00 +00:00
bowling.ml
ocaml: phase 5.1 bowling.ml baseline (10-pin bowling score, sample game = 167)
2026-05-10 02:26:10 +00:00
bracket_match.ml
ocaml: phase 5.1 bracket_match.ml baseline (5/9 balanced strings)
2026-05-11 01:02:59 +00:00
brainfuck.ml
ocaml: phase 5.1 brainfuck.ml baseline (subset interpreter)
2026-05-09 02:24:45 +00:00
bs_bounds.ml
ocaml: phase 5.1 bs_bounds.ml baseline (lower/upper bound, fingerprint 3211)
2026-05-11 01:22:31 +00:00
bsearch.ml
ocaml: phase 5.1 bsearch.ml baseline (binary search, position sum = 7)
2026-05-09 10:40:49 +00:00
btree.ml
ocaml: phase 5.1 btree.ml baseline (13/13 pass)
2026-05-08 17:52:49 +00:00
caesar.ml
ocaml: phase 5.1 caesar.ml baseline (ROT13 + s.[i] + Char ops)
2026-05-09 00:13:11 +00:00
calc.ml
ocaml: phase 5.1 calc.ml baseline (11/11 pass) + inline let-rec-and parser fix
2026-05-08 16:53:44 +00:00
catalan.ml
ocaml: phase 5.1 catalan.ml baseline (Catalan number C(5) = 42)
2026-05-09 21:06:10 +00:00
closures.ml
ocaml: phase 5.1 baseline 8/8 — quicksort + exceptions + closures
2026-05-08 13:44:28 +00:00
coin_change.ml
ocaml: phase 5.1 coin_change.ml baseline (DP, 67c with [1;5;10;25] = 6 coins)
2026-05-09 10:21:11 +00:00
coin_min.ml
ocaml: phase 5.1 coin_min.ml baseline (67 cents in US coins = 6)
2026-05-10 22:07:17 +00:00
convex_hull.ml
ocaml: phase 5.1 convex_hull.ml baseline (Andrew monotone chain, 5 vertices)
2026-05-11 00:09:06 +00:00
count_change.ml
ocaml: phase 5.1 count_change.ml baseline (ways to make 50c from [1;2;5;10;25] = 406)
2026-05-09 16:28:15 +00:00
count_inversions.ml
ocaml: phase 5.1 count_inversions.ml baseline (12 inversions via merge sort)
2026-05-10 05:01:08 +00:00
count_palindromes.ml
ocaml: phase 5.1 count_palindromes.ml baseline ("aabaa" -> 9 palindromes)
2026-05-11 03:14:23 +00:00
count_subarrays_k.ml
ocaml: phase 5.1 count_subarrays_k.ml baseline (sum-k subarrays = 7)
2026-05-11 03:04:14 +00:00
csv.ml
ocaml: phase 5.1 csv.ml baseline (split + int_of_string + fold_left)
2026-05-09 01:47:27 +00:00
dijkstra.ml
ocaml: phase 5.1 dijkstra.ml baseline (5-node SSSP, dist(0,4) = 7)
2026-05-10 04:20:47 +00:00
distinct_subseq.ml
ocaml: phase 5.1 distinct_subseq.ml baseline ("rabbit" in "rabbbit" = 3)
2026-05-11 01:12:33 +00:00
dp_word_break.ml
ocaml: phase 5.1 dp_word_break.ml baseline (4/5 strings segmentable)
2026-05-11 01:53:21 +00:00
egg_drop.ml
ocaml: phase 5.1 egg_drop.ml baseline (2 eggs, 36 floors -> 8 trials)
2026-05-10 22:58:13 +00:00
euler1.ml
ocaml: phase 5.1 euler1.ml baseline (Project Euler #1, multiples of 3 or 5 below 1000 = 233168)
2026-05-09 19:56:58 +00:00
euler2.ml
ocaml: phase 5.1 euler2.ml baseline (Project Euler #2, even Fib <= 4M = 4613732)
2026-05-09 20:05:45 +00:00
euler3.ml
ocaml: phase 5.1 euler3.ml baseline (largest prime factor of 13195 = 29)
2026-05-09 22:21:16 +00:00
euler4_small.ml
ocaml: phase 5.1 euler4_small.ml baseline (largest 2-digit palindrome product = 9009)
2026-05-09 21:59:23 +00:00
euler5.ml
ocaml: phase 5.1 euler5.ml baseline (smallest multiple of 1..20 = 232792560)
2026-05-09 21:35:59 +00:00
euler6.ml
ocaml: phase 5.1 euler6.ml baseline (Project Euler #6, sum^2 - sum_sq for 1..100 = 25164150)
2026-05-09 20:16:49 +00:00
euler7.ml
ocaml: phase 5.1 euler7.ml baseline (100th prime = 541)
2026-05-09 22:11:11 +00:00
euler9.ml
ocaml: phase 5.1 euler9.ml baseline (Project Euler #9, abc = 31875000)
2026-05-09 20:36:43 +00:00
euler10.ml
ocaml: phase 5.1 euler10.ml baseline (sum of primes <= 100 = 1060, scaled-down PE10)
2026-05-09 21:46:16 +00:00
euler14.ml
ocaml: phase 5.1 euler14.ml baseline (longest Collatz under 100, starting n = 97)
2026-05-09 22:53:27 +00:00
euler16.ml
ocaml: phase 5.1 euler16.ml baseline (digit sum of 2^15 = 26)
2026-05-09 22:43:45 +00:00
euler21_small.ml
ocaml: phase 5.1 euler21_small.ml baseline (sum of amicable numbers <= 300 = 504)
2026-05-09 23:27:15 +00:00
euler25.ml
ocaml: phase 5.1 euler25.ml baseline (first 12-digit Fibonacci index = 55)
2026-05-09 22:31:27 +00:00
euler28.ml
ocaml: phase 5.1 euler28.ml baseline (sum of diagonals in 7x7 spiral = 261)
2026-05-09 23:03:06 +00:00
euler29_small.ml
ocaml: phase 5.1 euler29_small.ml baseline (distinct a^b for 2<=a,b<=5 = 15)
2026-05-09 23:37:36 +00:00
euler30_cube.ml
ocaml: phase 5.1 euler30_cube.ml baseline (sum of digit-cube narcissistic numbers <= 999 = 1301)
2026-05-09 23:17:00 +00:00
euler34_small.ml
ocaml: phase 5.1 euler34_small.ml baseline (factorions <= 2000 = 145)
2026-05-09 23:50:25 +00:00
euler36.ml
ocaml: phase 5.1 euler36.ml baseline (sum of double-base palindromes <= 1000 = 1772)
2026-05-10 00:26:46 +00:00
euler40_small.ml
ocaml: phase 5.1 euler40_small.ml baseline (Champernowne digit product = 15)
2026-05-10 00:09:57 +00:00
exception_handle.ml
ocaml: phase 5.1 baseline 8/8 — quicksort + exceptions + closures
2026-05-08 13:44:28 +00:00
exception_user.ml
ocaml: phase 5.1 exception_user.ml baseline (user exception with payload, 4+5+7+10 = 26)
2026-05-09 12:04:42 +00:00
expected.json
ocaml: phase 5.1 interval_overlap.ml baseline (7 intervals, 6 overlapping pairs)
2026-05-11 03:24:45 +00:00
expr_eval.ml
ocaml: phase 5.1 expr_eval.ml baseline (9/9 pass)
2026-05-08 15:01:04 +00:00
expr_simp.ml
ocaml: phase 5.1 expr_simp.ml baseline (symbolic simplifier, eval(simp e) = 22)
2026-05-09 11:09:23 +00:00
factorial.ml
ocaml: phase 5.1 baseline OCaml programs (5/5 pass) + lookahead boundary
2026-05-08 13:33:24 +00:00
fenwick_tree.ml
ocaml: phase 5.1 fenwick_tree.ml baseline (BIT over 8 elements, fingerprint 228)
2026-05-10 23:48:46 +00:00
fib_doubling.ml
ocaml: phase 5.1 fib_doubling.ml baseline (Fibonacci by doubling, fib(40) = 102334155)
2026-05-09 17:36:24 +00:00
fib_mod.ml
ocaml: phase 5.1 fib_mod.ml baseline (Fibonacci mod prime, fib(100) mod 1000003 = 391360)
2026-05-09 15:53:47 +00:00
fizz_classifier.ml
ocaml: phase 5.1 fizz_classifier.ml baseline (FizzBuzz with polymorphic variants, 1..30 weighted = 540)
2026-05-09 20:56:31 +00:00
fizzbuzz.ml
ocaml: phase 5.1 fizzbuzz.ml baseline (12/12 pass)
2026-05-08 17:44:07 +00:00
flatten_tree.ml
ocaml: phase 5.1 flatten_tree.ml baseline (parametric ADT flatten, sum 1..7 = 28)
2026-05-09 11:52:19 +00:00
flood_fill.ml
ocaml: phase 5.1 flood_fill.ml baseline (largest grid component = 7)
2026-05-10 21:57:42 +00:00
floyd_cycle.ml
ocaml: phase 5.1 floyd_cycle.ml baseline (tortoise-hare, mu=0 lam=8 -> 8)
2026-05-11 02:54:50 +00:00
floyd_warshall.ml
ocaml: phase 5.1 floyd_warshall.ml baseline (4-node APSP, dist(0,3)=9)
2026-05-10 05:41:02 +00:00
fraction.ml
ocaml: phase 5.1 fraction.ml baseline (rational arithmetic, 4/3 -> num+den=7)
2026-05-09 06:05:31 +00:00
frequency.ml
ocaml: phase 5.1 frequency.ml baseline + Format module alias (+2 tests, 498 total)
2026-05-09 01:11:53 +00:00
gcd_lcm.ml
ocaml: phase 5.1 gcd_lcm.ml baseline (Euclidean gcd + lcm, 12+12+36 = 60)
2026-05-09 11:42:52 +00:00
gray_code.ml
ocaml: phase 5.1 gray_code.ml baseline (4-bit reflected Gray code, sum+len = 136)
2026-05-09 19:08:19 +00:00
grep_count.ml
ocaml: phase 5.1 grep_count.ml baseline (substring-aware line filter, 3 matches)
2026-05-09 09:34:40 +00:00
grid_paths.ml
ocaml: phase 5.1 grid_paths.ml baseline (count paths in 4x6 grid = 210)
2026-05-09 17:45:52 +00:00
group_consec.ml
ocaml: phase 5.1 group_consec.ml baseline (group consecutive equals, 5*10+3 = 53)
2026-05-09 14:40:22 +00:00
hailstone.ml
ocaml: phase 5.1 hailstone.ml baseline (Collatz length from 27 = 111 steps)
2026-05-09 13:30:46 +00:00
hamming.ml
ocaml: phase 5.1 hamming.ml baseline (Hamming distance, 3+2-1 = 4)
2026-05-09 18:27:50 +00:00
hanoi.ml
ocaml: phase 5.1 hanoi.ml baseline (Tower of Hanoi move count, n=10 -> 1023)
2026-05-09 08:21:19 +00:00
harshad.ml
ocaml: phase 5.1 harshad.ml baseline (count Niven/Harshad numbers <= 100 = 33)
2026-05-10 02:46:20 +00:00
hist.ml
ocaml: phase 5.1 hist.ml baseline (Hashtbl int histogram, total * max = 75)
2026-05-09 15:02:13 +00:00
histogram_area.ml
ocaml: phase 5.1 histogram_area.ml baseline (largest rectangle = 10)
2026-05-11 01:42:26 +00:00
huffman.ml
ocaml: phase 5.1 huffman.ml baseline (Huffman tree WPL = 224)
2026-05-10 06:21:06 +00:00
int_sqrt.ml
ocaml: phase 5.1 int_sqrt.ml baseline (Newton integer sqrt, 12+14+1000+1 = 1027)
2026-05-09 17:55:07 +00:00
interval_overlap.ml
ocaml: phase 5.1 interval_overlap.ml baseline (7 intervals, 6 overlapping pairs)
2026-05-11 03:24:45 +00:00
is_prime.ml
ocaml: phase 5.1 is_prime.ml baseline (count primes <= 100 = 25)
2026-05-09 21:16:40 +00:00
island_count.ml
ocaml: phase 5.1 island_count.ml baseline (6x7 grid, 5 components)
2026-05-11 02:04:08 +00:00
josephus.ml
ocaml: phase 5.1 josephus.ml baseline (n=50 k=3, survivor at position 11)
2026-05-10 03:22:29 +00:00
json_pretty.ml
ocaml: phase 5.1 json_pretty.ml baseline (recursive ADT to string, len = 24)
2026-05-09 07:41:01 +00:00
kadane.ml
ocaml: phase 5.1 kadane.ml baseline (max subarray sum = 6)
2026-05-09 10:07:12 +00:00
kmp.ml
ocaml: phase 5.1 kmp.ml baseline (5 occurrences of "abab" in haystack)
2026-05-10 04:08:53 +00:00
knapsack.ml
ocaml: phase 5.1 knapsack.ml baseline (0/1 knapsack, cap=8 -> 36)
2026-05-10 04:38:59 +00:00
kth_two.ml
ocaml: phase 5.1 kth_two.ml baseline (8th smallest of two sorted = 8)
2026-05-11 02:44:40 +00:00
lambda_calc.ml
ocaml: phase 5.1 lambda_calc.ml baseline (17/17 pass)
2026-05-08 19:49:08 +00:00
lcs.ml
ocaml: phase 5.1 lcs.ml baseline (LCS of "ABCBDAB" and "BDCAB" = 4)
2026-05-10 04:29:58 +00:00
lev_iter.ml
ocaml: phase 5.1 lev_iter.ml baseline (sum of 5 edit distances = 16)
2026-05-10 06:53:38 +00:00
levenshtein.ml
ocaml: phase 5.1 levenshtein.ml baseline (no-memo edit distance, sum=11)
2026-05-09 00:23:58 +00:00
lis.ml
ocaml: phase 5.1 array literals [|...|] + lis.ml baseline (LIS = 6)
2026-05-10 03:41:19 +00:00
list_ops.ml
ocaml: phase 5.1 baseline OCaml programs (5/5 pass) + lookahead boundary
2026-05-08 13:33:24 +00:00
lps_dp.ml
ocaml: phase 5.1 lps_dp.ml baseline (LPS "BBABCBCAB" = 7)
2026-05-11 01:32:41 +00:00
lru_cache.ml
ocaml: parser accepts top-level tuple patterns in match cases
2026-05-11 00:31:08 +00:00
luhn.ml
ocaml: phase 5.1 luhn.ml baseline (Luhn check-digit, 2/4 inputs valid)
2026-05-09 15:42:01 +00:00
magic_square.ml
ocaml: phase 5.1 magic_square.ml baseline (5x5 Siamese, diag sum = 65)
2026-05-10 23:28:29 +00:00
majority_vote.ml
ocaml: phase 5.1 majority_vote.ml baseline (Boyer-Moore majority, [3;3;4;2;4;4;2;4;4] = 4)
2026-05-09 19:27:14 +00:00
manacher.ml
ocaml: parser accepts if/match/let/fun as rhs of <- and :=
2026-05-10 06:11:57 +00:00
mat_mul.ml
ocaml: phase 5.1 mat_mul.ml baseline (3x3 row-major matrix multiply, sum = 621)
2026-05-09 11:00:00 +00:00
matrix_power.ml
ocaml: phase 5.1 matrix_power.ml baseline (F(30) = 832040 via 2x2 matrix pow)
2026-05-10 23:18:26 +00:00
max_path_tree.ml
ocaml: phase 5.1 max_path_tree.ml baseline (max root-to-leaf sum, 1+3+7 = 11)
2026-05-09 15:22:28 +00:00
max_product3.ml
ocaml: phase 5.1 max_product3.ml baseline (max product of 3, with negatives -> 300)
2026-05-09 20:46:42 +00:00
max_run.ml
ocaml: phase 5.1 max_run.ml baseline (longest consecutive run, 4+1+0 = 5)
2026-05-09 18:58:32 +00:00
memo_fib.ml
ocaml: phase 5.1 memo_fib.ml baseline (16/16 pass)
2026-05-08 19:10:49 +00:00
merge_intervals.ml
ocaml: phase 5.1 merge_intervals.ml baseline (LeetCode #56, total length 9+3 = 12)
2026-05-09 18:39:46 +00:00
merge_sort.ml
ocaml: phase 5.1 merge_sort.ml baseline (user mergesort, sum=44)
2026-05-09 05:00:50 +00:00
merge_two.ml
ocaml: phase 5.1 merge_two.ml baseline (merge two sorted lists, length*sum = 441)
2026-05-09 17:24:53 +00:00
min_cost_path.ml
ocaml: phase 5.1 min_cost_path.ml baseline (4x4 grid DP, optimal cost 12)
2026-05-10 22:37:44 +00:00
mod_inverse.ml
ocaml: phase 5.1 mod_inverse.ml baseline (extended Euclidean, inverse sum = 27)
2026-05-09 15:11:46 +00:00
module_use.ml
ocaml: phase 5.1 baseline OCaml programs (5/5 pass) + lookahead boundary
2026-05-08 13:33:24 +00:00
monotonic.ml
ocaml: phase 5.1 monotonic.ml baseline (monotonicity check, 4/5 inputs monotonic)
2026-05-09 19:37:11 +00:00
mortgage.ml
ocaml: phase 5.1 mortgage.ml baseline (monthly payment, 200k @ 5% / 30y = $1073)
2026-05-09 14:52:13 +00:00
mst_kruskal.ml
ocaml: phase 5.1 mst_kruskal.ml baseline (5-node MST weight 11)
2026-05-10 05:21:14 +00:00
mutable_record.ml
ocaml: phase 5.1 mutable_record.ml baseline (14/14 pass)
2026-05-08 18:43:19 +00:00
newton_sqrt.ml
ocaml: phase 5.1 newton_sqrt.ml baseline (Newton's method, sqrt(2)*1000 = 1414)
2026-05-09 08:29:01 +00:00
next_greater.ml
ocaml: phase 5.1 next_greater.ml baseline (monotonic stack, sum 153)
2026-05-10 23:58:50 +00:00
next_permutation.ml
ocaml: phase 5.1 next_permutation.ml baseline (5! - 1 = 119 successors)
2026-05-10 21:47:52 +00:00
number_words.ml
ocaml: phase 5.1 number_words.ml baseline (letter count of 1..19 spelled out = 106)
2026-05-10 01:39:25 +00:00
option_match.ml
ocaml: phase 5.1 baseline OCaml programs (5/5 pass) + lookahead boundary
2026-05-08 13:33:24 +00:00
palindrome_part.ml
ocaml: phase 5.1 palindrome_part.ml baseline (min cuts "aabba" = 1)
2026-05-11 02:14:44 +00:00
palindrome_sum.ml
ocaml: phase 5.1 palindrome_sum.ml baseline (sum of 3-digit palindromes = 49500)
2026-05-10 01:29:52 +00:00
palindrome.ml
ocaml: phase 5.1 palindrome.ml baseline (two-pointer check, 4/6 inputs match)
2026-05-09 10:31:22 +00:00
pancake_sort.ml
ocaml: phase 5.1 pancake_sort.ml baseline (in-place pancake sort, 9 flips -> 910)
2026-05-09 16:03:22 +00:00
paren_depth.ml
ocaml: phase 5.1 paren_depth.ml baseline (max nesting depth, 3+3+1 = 7)
2026-05-09 16:13:05 +00:00
partition_count.ml
ocaml: phase 5.1 partition_count.ml baseline (p(15) = 176)
2026-05-10 03:13:36 +00:00
partition.ml
ocaml: phase 5.1 partition.ml baseline (stable partition, evens*100 + odds = 3025)
2026-05-09 21:26:31 +00:00
pascal.ml
ocaml: phase 5.1 pascal.ml baseline (Pascal triangle row 10 middle = C(10,5) = 252)
2026-05-09 09:57:18 +00:00
peano.ml
ocaml: phase 5.1 peano.ml baseline (Peano arithmetic, 5*6 = 30)
2026-05-09 16:38:09 +00:00
perfect.ml
ocaml: phase 5.1 perfect.ml baseline (count perfect numbers <= 500 = 3)
2026-05-10 01:02:18 +00:00
permutations_gen.ml
ocaml: phase 5.1 permutations_gen.ml baseline (24 perms, 12 with a<b ends)
2026-05-11 02:34:58 +00:00
pi_leibniz.ml
ocaml: phase 5.1 pi_leibniz.ml baseline + int_of_float fix (1000 terms x 100 = 314)
2026-05-09 07:19:52 +00:00
poly_stack.ml
ocaml: phase 1+5.1 type aliases + poly_stack baseline (+3 tests, 469 / 19 baseline)
2026-05-08 20:49:26 +00:00
polygon_area.ml
ocaml: phase 5.1 polygon_area.ml baseline (pentagon 2x area = 32)
2026-05-10 22:47:22 +00:00
pow_mod.ml
ocaml: phase 5.1 pow_mod.ml baseline (modular exponentiation, sum = 738639)
2026-05-09 17:15:47 +00:00
powerset_target.ml
ocaml: phase 5.1 powerset_target.ml baseline (subsets of {1..10} summing to 15 = 20)
2026-05-11 00:42:08 +00:00
prefix_sum.ml
ocaml: phase 5.1 prefix_sum.ml baseline (precomputed sums + range queries, 14+25+27 = 66)
2026-05-09 14:21:24 +00:00
pretty_table.ml
ocaml: phase 5.1 pretty_table.ml baseline (Buffer + Printf widths, len = 64)
2026-05-09 09:24:41 +00:00
prime_factors.ml
ocaml: phase 5.1 prime_factors.ml baseline (trial-division, 360 factor sum = 17)
2026-05-09 12:44:02 +00:00
pythagorean.ml
ocaml: phase 5.1 pythagorean.ml baseline (primitive Pythagorean triples with hyp <= 100 = 16)
2026-05-10 03:02:17 +00:00
queens.ml
ocaml: phase 5.1 queens.ml baseline (15/15 pass)
2026-05-08 19:04:04 +00:00
quickselect.ml
ocaml: phase 5.1 quickselect.ml baseline (median of 9 elements = 5)
2026-05-10 03:50:59 +00:00
quicksort.ml
ocaml: phase 5.1 baseline 8/8 — quicksort + exceptions + closures
2026-05-08 13:44:28 +00:00
radix_sort.ml
ocaml: phase 5.1 radix_sort.ml baseline (LSD radix sort, sentinel 802002)
2026-05-10 22:17:40 +00:00
regex_simple.ml
ocaml: phase 5.1 regex_simple.ml baseline (./* matcher, 7/28 match)
2026-05-11 02:25:04 +00:00
reverse_int.ml
ocaml: phase 5.1 reverse_int.ml baseline (digit-reverse sum = 54329)
2026-05-10 02:36:37 +00:00
rolling_hash.ml
ocaml: phase 5.1 rolling_hash.ml baseline (Rabin-Karp, 6 "abc" matches)
2026-05-10 06:34:13 +00:00
roman.ml
ocaml: phase 5.1 roman.ml baseline + top-level 'let () = expr'
2026-05-08 23:40:36 +00:00
rpn.ml
ocaml: phase 5.1 rpn.ml baseline (Reverse Polish Notation evaluator, [3 4 + 2 * 5 -] = 9)
2026-05-09 08:39:56 +00:00
run_decode.ml
ocaml: phase 5.1 run_decode.ml baseline (RLE decode, expansion sum = 21)
2026-05-09 16:47:56 +00:00
run_length.ml
ocaml: phase 5.1 run_length.ml baseline (RLE, sum-of-counts = 11)
2026-05-09 09:47:25 +00:00
run.sh
ocaml: phase 5.1 caesar.ml baseline (ROT13 + s.[i] + Char ops)
2026-05-09 00:13:11 +00:00
safe_div.ml
ocaml: phase 5.1 safe_div.ml baseline + Result.equal/compare/iter_error (+3 tests, 592 total)
2026-05-09 06:47:47 +00:00
segment_tree.ml
ocaml: phase 5.1 segment_tree.ml baseline (range-sum tree, fingerprint 4232)
2026-05-10 23:38:40 +00:00
shuffle.ml
ocaml: phase 5.1 shuffle.ml baseline (Fisher-Yates with deterministic Random)
2026-05-09 07:31:33 +00:00
sieve.ml
ocaml: phase 5.1 sieve.ml baseline (Sieve of Eratosthenes)
2026-05-09 02:16:18 +00:00
simpson_int.ml
ocaml: phase 5.1 simpson_int.ml baseline (Simpson 1/3 rule, integral_0^1 x^2 -> 10000)
2026-05-09 18:09:33 +00:00
stable_unique.ml
ocaml: phase 5.1 stable_unique.ml baseline (Hashtbl dedupe preserving order, 8+38 = 46)
2026-05-09 16:56:46 +00:00
subseq_check.ml
ocaml: phase 5.1 subseq_check.ml baseline (subsequence test, 3/5 yes)
2026-05-09 18:49:00 +00:00
subset_sum.ml
ocaml: phase 5.1 subset_sum.ml baseline (count subsets of [1..8] summing to 10 = 8)
2026-05-09 13:46:40 +00:00
sum_squares.ml
ocaml: phase 5.1 baseline OCaml programs (5/5 pass) + lookahead boundary
2026-05-08 13:33:24 +00:00
tail_factorial.ml
ocaml: phase 5.1 tail_factorial.ml baseline (12! via tail-recursion = 479001600)
2026-05-10 02:05:09 +00:00
tarjan_scc.ml
ocaml: phase 5.1 tarjan_scc.ml baseline (8-node digraph, 4 SCCs)
2026-05-10 07:06:29 +00:00
tic_tac_toe.ml
ocaml: phase 5.1 tic_tac_toe.ml baseline (3x3 winner check, X wins top row = 1)
2026-05-09 14:00:49 +00:00
topo_dfs.ml
ocaml: phase 5.1 topo_dfs.ml baseline (DFS topo sort, fingerprint 24135)
2026-05-10 22:27:18 +00:00
topo_sort.ml
ocaml: phase 5.1 topo_sort.ml baseline (6-node DAG, all 6 ordered)
2026-05-10 04:51:15 +00:00
tree_depth.ml
ocaml: phase 5.1 tree_depth.ml baseline (binary tree depth, longest path = 4)
2026-05-09 17:06:10 +00:00
triangle_div.ml
ocaml: phase 5.1 triangle_div.ml baseline (first triangle with >10 divisors = 120)
2026-05-10 01:17:11 +00:00
triangle.ml
ocaml: phase 5.1 triangle.ml baseline (Pascal-shape min path sum, 2+3+5+1 = 11)
2026-05-09 15:32:11 +00:00
trie.ml
ocaml: phase 5.1 trie.ml baseline (prefix tree, 6/9 word lookups match)
2026-05-10 05:11:12 +00:00
twosum.ml
ocaml: phase 5.1 twosum.ml baseline (LeetCode #1 one-pass hashmap, index sum = 5)
2026-05-09 13:15:05 +00:00
union_find.ml
ocaml: phase 5.1 union_find.ml baseline (10 nodes, 6 unions, 4 components)
2026-05-10 03:59:56 +00:00
unique_set.ml
ocaml: phase 5.1 unique_set.ml baseline (Set.Make + IntOrd, count = 9)
2026-05-09 05:44:35 +00:00
validate.ml
ocaml: phase 5.1 validate.ml baseline (Either-based validation, 3 errs * 100 + 117 = 417)
2026-05-09 08:11:07 +00:00
wildcard_match.ml
ocaml: phase 5.1 wildcard_match.ml baseline (* / ? matcher, 6/18 match)
2026-05-11 00:52:42 +00:00
word_count.ml
ocaml: phase 5.1 word_count.ml baseline (10/10 pass)
2026-05-08 16:11:03 +00:00
word_freq.ml
ocaml: phase 5.1 word_freq.ml baseline (Map.Make on String, distinct = 8)
2026-05-09 08:01:21 +00:00
xor_cipher.ml
ocaml: phase 5.1 xor_cipher.ml baseline (XOR roll-key encryption, round-trip = 601)
2026-05-09 18:19:02 +00:00
zerosafe.ml
ocaml: phase 5.1 zerosafe.ml baseline (Option-chained safe division, sum = 28)
2026-05-10 01:49:23 +00:00
zigzag.ml
ocaml: phase 5.1 zigzag.ml baseline (interleave two lists, sum 1..10 = 55)
2026-05-09 14:30:55 +00:00
zip_unzip.ml
ocaml: phase 5.1 zip_unzip.ml baseline (zip/unzip round-trip, sum-product = 1000)
2026-05-09 11:33:30 +00:00