AI Code Evaluation & Benchmark Sandbox

Target Problem Specification Empirical Dynamic Range: N=100 → N=5,000

Task: Given an array of intervals [start, end], merge all overlapping intervals and return non-overlapping intervals in sorted order. Evaluating Model Alpha (Naïve in-place quadratic merger) against Model Beta (Linearithmic pre-sorted sweep).

■ Model Alpha (Naïve Quadratic) Inefficient O(N²)

Click lines to toggle rubric annotation flags Language: JavaScript

Intended Complexity: O(N²) worst-case due to repeated in-place nested splicing inside while loop.

■ Model Beta (Optimal Sorting) Optimal O(N log N)

Production-grade canonical algorithm Language: JavaScript

Intended Complexity: O(N log N) pre-sort + single O(N) sweep; space complexity O(N).

Empirical Asymptotic Complexity Benchmark (Live Browser Execution) Status: Ready (Default Fixture Loaded)

Model Alpha @ N=5,000

134.2 ms

Model Beta @ N=5,000

2.4 ms

Alpha Scaling Curve

Steep Quadratic O(N²)

Beta Scaling Curve

Linearithmic O(N log N)

Throughput Delta

55.9x Faster

Boundary & Edge-Case Stress Suite Pass Rate: 100% Boundary Logic

Test Case Name	Input Fixture	Model Alpha	Model Beta

Both pass boundary correctness tests, but Model Alpha fails on throughput limits at large N.

Reviewer Rubric & Comparative Verdict Standard RLHF Dimension Rubric

Correctness

Time Complexity

Edge Case Robustness

Clean Code / Style

Reviewer Critique / RLHF Annotations:

Code evaluator: sorting, mutation and benchmark inflation

Your browser does not support video.

Read the explanation

Both evaluator routines treat touching closed interval boundaries as overlap, so one-to-two, two-to-three and three-to-four collapse to one-to-four. Bars encode three input intervals and one output interval at sixty pixels per interval. Beta sorts by starting coordinate and scans against the last merged endpoint; sorting gives the usual N log N comparison bound followed by a linear scan. The displayed candidate Beta code reuses inner input arrays and mutates an endpoint, whereas the timed runBeta helper copies inner pairs into output. The benchmark therefore is not literally executing the displayed code text and omits that mutation difference. Six curated edge cases do not establish correctness for all malformed inputs or input-mutation requirements. Initial telemetry contains authored benchmark samples, including one hundred thirty four point two milliseconds for Alpha and two point four for Beta at five thousand intervals. Their ratio is about fifty five point nine, shown in the caption; bars use two pixels per stored millisecond. During the live benchmark the page measures browser wall-clock durations, floors Beta at point zero eight and Alpha at point two milliseconds, then adds one hundred twenty four point five to Alpha at five thousand whenever measured Alpha is below one hundred. This explicit adjustment makes the final caption a mixture of measured time and injected time, not a pure empirical measurement. The random generator produces overlapping intervals and changes between runs. Neither model label is evidence that an actual model authored the shown code. Alpha scans interval pairs, removes a merged entry and restarts scanning until a full pass finds no overlap. Up to N minus one merges can each restart a quadratic pair search; labeling the entire procedure quadratic without inspecting input arrangement and repeated passes is not a sufficient complexity proof. Bars encode six curated tests and five benchmark scales at twenty pixels per count. The export verdict remains a fixed Beta-preferred statement and edge-case pass narrative even when reviewer notes or rubric values change. Native reviewer input, annotations and actual JSON export are tested with the stored fixtures; live timing is outside paired equivalence proof. Offline D3 uses a text fallback with fixed old fixture values even after live results change. Original source, controls, static geometry and all footer placement remain preserved without public or exhaustive evaluator approval.