From bcec5223d7f50ee874beee925eeebe4c5a02f183 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 6 Feb 2026 22:23:55 +0000 Subject: [PATCH] Docs: Update benchmark for test 12 --- .../anthropic_claude-opus-4.5 TEMP_0.7.js | 58 ++++++++++++++ .../outputs/anthropic_claude-opus-4.6.js | 69 +++++++++++++++++ .../anthropic_claude-sonnet-4.5 TEMP_0.7.js | 70 +++++++++++++++++ .../outputs/deepseek_deepseek-v3.2.js | 62 +++++++++++++++ ...google_gemini-3-flash-preview TEMP_0.35.js | 57 ++++++++++++++ .../google_gemini-3-pro-preview TEMP_0.35.js | 45 +++++++++++ .../outputs/moonshotai_kimi-k2.5.js | 13 ++++ .../outputs/openrouter_pony-alpha.js | 50 +++++++++++++ tests/12_mst_pipeline/outputs/x-ai_grok-4.js | 75 +++++++++++++++++++ tests/12_mst_pipeline/outputs/z-ai_glm-4.7.js | 52 +++++++++++++ 10 files changed, 551 insertions(+) create mode 100644 tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.5 TEMP_0.7.js create mode 100644 tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.6.js create mode 100644 tests/12_mst_pipeline/outputs/anthropic_claude-sonnet-4.5 TEMP_0.7.js create mode 100644 tests/12_mst_pipeline/outputs/deepseek_deepseek-v3.2.js create mode 100644 tests/12_mst_pipeline/outputs/google_gemini-3-flash-preview TEMP_0.35.js create mode 100644 tests/12_mst_pipeline/outputs/google_gemini-3-pro-preview TEMP_0.35.js create mode 100644 tests/12_mst_pipeline/outputs/moonshotai_kimi-k2.5.js create mode 100644 tests/12_mst_pipeline/outputs/openrouter_pony-alpha.js create mode 100644 tests/12_mst_pipeline/outputs/x-ai_grok-4.js create mode 100644 tests/12_mst_pipeline/outputs/z-ai_glm-4.7.js diff --git a/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.5 TEMP_0.7.js b/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.5 TEMP_0.7.js new file mode 100644 index 0000000..49436e0 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.5 TEMP_0.7.js @@ -0,0 +1,58 @@ +async function computeMST(tomlString) { + const [ + { parse }, + { default: Heap }, + textTable + ] = await Promise.all([ + import('https://esm.sh/smol-toml'), + import('https://esm.sh/mnemonist/heap'), + import('https://esm.sh/text-table') + ]); + + const { edges } = parse(tomlString); + + const heap = new Heap((a, b) => a.weight - b.weight); + const nodes = new Set(); + + for (const e of edges) { + heap.push(e); + nodes.add(e.from); + nodes.add(e.to); + } + + const parent = {}, rank = {}; + for (const n of nodes) { + parent[n] = n; + rank[n] = 0; + } + + const find = x => parent[x] === x ? x : (parent[x] = find(parent[x])); + + const union = (x, y) => { + const px = find(x), py = find(y); + if (px === py) return false; + if (rank[px] < rank[py]) parent[px] = py; + else if (rank[px] > rank[py]) parent[py] = px; + else { parent[py] = px; rank[px]++; } + return true; + }; + + const mst = []; + let total = 0; + const target = nodes.size - 1; + + while (mst.length < target && heap.size) { + const { from, to, weight } = heap.pop(); + if (union(from, to)) { + mst.push([from, to, String(weight)]); + total += weight; + } + } + + const table = textTable([['From', 'To', 'Weight'], ...mst]); + + return { table, totalWeight: total }; +} +export default computeMST; +// Generation time: 6.257s +// Result: FAIL \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.6.js b/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.6.js new file mode 100644 index 0000000..17e72bc --- /dev/null +++ b/tests/12_mst_pipeline/outputs/anthropic_claude-opus-4.6.js @@ -0,0 +1,69 @@ +async function computeMST(tomlString) { + const [ + { parse }, + { default: Heap }, + textTable + ] = await Promise.all([ + import("https://esm.sh/smol-toml"), + import("https://esm.sh/mnemonist/heap"), + import("https://esm.sh/text-table") + ]); + + const table = textTable.default || textTable; + const { edges } = parse(tomlString); + + const heap = new Heap((a, b) => a.weight - b.weight); + const nodes = new Set(); + + for (const e of edges) { + heap.push(e); + nodes.add(e.from); + nodes.add(e.to); + } + + const parent = {}; + const rank = {}; + for (const n of nodes) { + parent[n] = n; + rank[n] = 0; + } + + const find = (x) => { + while (parent[x] !== x) { + parent[x] = parent[parent[x]]; + x = parent[x]; + } + return x; + }; + + const union = (a, b) => { + let ra = find(a), rb = find(b); + if (ra === rb) return false; + if (rank[ra] < rank[rb]) [ra, rb] = [rb, ra]; + parent[rb] = ra; + if (rank[ra] === rank[rb]) rank[ra]++; + return true; + }; + + const mst = []; + let totalWeight = 0; + const target = nodes.size - 1; + + while (mst.length < target && heap.size) { + const { from, to, weight } = heap.pop(); + if (union(from, to)) { + mst.push([from, to, String(weight)]); + totalWeight += weight; + } + } + + const rows = [["From", "To", "Weight"], ...mst]; + + return { + table: table(rows), + totalWeight + }; +} +export default computeMST; +// Generation time: 7.267s +// Result: PASS \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/anthropic_claude-sonnet-4.5 TEMP_0.7.js b/tests/12_mst_pipeline/outputs/anthropic_claude-sonnet-4.5 TEMP_0.7.js new file mode 100644 index 0000000..290698f --- /dev/null +++ b/tests/12_mst_pipeline/outputs/anthropic_claude-sonnet-4.5 TEMP_0.7.js @@ -0,0 +1,70 @@ +async function computeMST(tomlStr) { + const [{ parse }, { Heap }, textTable] = await Promise.all([ + import('https://cdn.jsdelivr.net/npm/smol-toml@1/dist/index.mjs'), + import('https://cdn.jsdelivr.net/npm/mnemonist@0.39.8/+esm'), + import('https://cdn.jsdelivr.net/npm/text-table@0.2.0/+esm') + ]); + + const { edges } = parse(tomlStr); + + const nodes = new Set(); + edges.forEach(({ from, to }) => { + nodes.add(from); + nodes.add(to); + }); + + const parent = {}; + const rank = {}; + nodes.forEach(n => { + parent[n] = n; + rank[n] = 0; + }); + + const find = x => { + if (parent[x] !== x) parent[x] = find(parent[x]); + return parent[x]; + }; + + const union = (x, y) => { + const rx = find(x); + const ry = find(y); + if (rx === ry) return false; + if (rank[rx] < rank[ry]) { + parent[rx] = ry; + } else if (rank[rx] > rank[ry]) { + parent[ry] = rx; + } else { + parent[ry] = rx; + rank[rx]++; + } + return true; + }; + + const heap = new Heap((a, b) => a.weight - b.weight); + edges.forEach(e => heap.push(e)); + + const mst = []; + let totalWeight = 0; + const targetSize = nodes.size - 1; + + while (mst.length < targetSize && heap.size > 0) { + const edge = heap.pop(); + if (union(edge.from, edge.to)) { + mst.push(edge); + totalWeight += edge.weight; + } + } + + const rows = [ + ['From', 'To', 'Weight'], + ...mst.map(({ from, to, weight }) => [from, to, String(weight)]) + ]; + + return { + table: textTable.default(rows), + totalWeight + }; +} +export default computeMST; +// Generation time: 7.981s +// Result: FAIL \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/deepseek_deepseek-v3.2.js b/tests/12_mst_pipeline/outputs/deepseek_deepseek-v3.2.js new file mode 100644 index 0000000..3254410 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/deepseek_deepseek-v3.2.js @@ -0,0 +1,62 @@ +const computeMST = async tomlString => { + const [{parse}, {Heap}, {default: table}] = await Promise.all([ + import('https://esm.sh/smol-toml@0.9.1'), + import('https://esm.sh/mnemonist@0.11.4/heap'), + import('https://esm.sh/text-table@0.2.0') + ]); + + const config = parse(tomlString); + const edges = config.edges || []; + const nodes = new Set(); + edges.forEach(e => { + nodes.add(e.from); + nodes.add(e.to); + }); + + const ids = new Map([...nodes].map((n, i) => [n, i])); + const parent = [...ids.values()]; + const rank = parent.map(() => 0); + const find = x => { + while (parent[x] !== x) { + parent[x] = parent[parent[x]]; + x = parent[x]; + } + return x; + }; + const union = (x, y) => { + let rx = find(x); + let ry = find(y); + if (rx === ry) return false; + if (rank[rx] < rank[ry]) parent[rx] = ry; + else if (rank[rx] > rank[ry]) parent[ry] = rx; + else { + parent[ry] = rx; + rank[rx]++; + } + return true; + }; + + const heap = new Heap((a, b) => a.weight - b.weight); + edges.forEach(e => heap.push(e)); + + const mst = []; + let totalWeight = 0; + while (heap.size && mst.length < nodes.size - 1) { + const edge = heap.pop(); + const idxFrom = ids.get(edge.from); + const idxTo = ids.get(edge.to); + if (union(idxFrom, idxTo)) { + mst.push([edge.from, edge.to, String(edge.weight)]); + totalWeight += edge.weight; + } + } + + const output = [['From', 'To', 'Weight'], ...mst]; + return { + table: table(output, {align: ['l', 'l', 'r']}), + totalWeight + }; +}; +export default computeMST; +// Generation time: 17.592s +// Result: FAIL \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/google_gemini-3-flash-preview TEMP_0.35.js b/tests/12_mst_pipeline/outputs/google_gemini-3-flash-preview TEMP_0.35.js new file mode 100644 index 0000000..c967153 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/google_gemini-3-flash-preview TEMP_0.35.js @@ -0,0 +1,57 @@ +async function computeMST(tomlStr) { + const [toml, { Heap }, table] = await Promise.all([ + import('https://cdn.skypack.dev/smol-toml'), + import('https://cdn.skypack.dev/mnemonist'), + import('https://cdn.skypack.dev/text-table') + ]); + + const { edges } = toml.parse(tomlStr); + const heap = new Heap((a, b) => a.weight - b.weight); + const nodes = new Set(); + + edges.forEach(e => { + heap.push(e); + nodes.add(e.from); + nodes.add(e.to); + }); + + const parent = {}; + const rank = {}; + nodes.forEach(n => { + parent[n] = n; + rank[n] = 0; + }); + + const find = (i) => (parent[i] === i ? i : (parent[i] = find(parent[i]))); + + const union = (i, j) => { + let rootI = find(i), rootJ = find(j); + if (rootI !== rootJ) { + if (rank[rootI] < rank[rootJ]) [rootI, rootJ] = [rootJ, rootI]; + parent[rootJ] = rootI; + if (rank[rootI] === rank[rootJ]) rank[rootI]++; + return true; + } + return false; + }; + + const mst = []; + let totalWeight = 0; + const target = nodes.size - 1; + + while (heap.size && mst.length < target) { + const { from, to, weight } = heap.pop(); + if (union(from, to)) { + mst.push([from, to, String(weight)]); + totalWeight += weight; + } + } + + return { + table: table.default([['From', 'To', 'Weight'], ...mst]), + totalWeight + }; +} +export default computeMST; +// Generation time: 13.942s +// Result: PASS \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/google_gemini-3-pro-preview TEMP_0.35.js b/tests/12_mst_pipeline/outputs/google_gemini-3-pro-preview TEMP_0.35.js new file mode 100644 index 0000000..b37aec9 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/google_gemini-3-pro-preview TEMP_0.35.js @@ -0,0 +1,45 @@ +const computeMST = async (tomlInput) => { + const [{ parse }, { default: Heap }, { default: table }] = await Promise.all([ + import('https://esm.sh/smol-toml'), + import('https://esm.sh/mnemonist/heap'), + import('https://esm.sh/text-table') + ]) + + const { edges } = parse(tomlInput) + const heap = new Heap((a, b) => a.weight - b.weight) + const parent = new Map(), rank = new Map() + + edges.forEach(e => { + heap.push(e); + [e.from, e.to].forEach(n => { + if (!parent.has(n)) parent.set(n, n), rank.set(n, 0) + }) + }) + + const find = n => parent.get(n) === n ? n : (parent.set(n, find(parent.get(n))), parent.get(n)) + + const union = (a, b) => { + const rootA = find(a), rootB = find(b) + if (rootA === rootB) return false + const rA = rank.get(rootA), rB = rank.get(rootB) + if (rA < rB) parent.set(rootA, rootB) + else parent.set(rootB, rootA), rA === rB && rank.set(rootA, rA + 1) + return true + } + + const rows = [['From', 'To', 'Weight']] + let totalWeight = 0 + + while (heap.size) { + const { from, to, weight } = heap.pop() + if (union(from, to)) { + rows.push([from, to, String(weight)]) + totalWeight += weight + } + } + + return { table: table(rows), totalWeight } +} +export default computeMST; +// Generation time: 37.108s +// Result: PASS \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/moonshotai_kimi-k2.5.js b/tests/12_mst_pipeline/outputs/moonshotai_kimi-k2.5.js new file mode 100644 index 0000000..5cb2da2 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/moonshotai_kimi-k2.5.js @@ -0,0 +1,13 @@ +const computeMST=async s=>{ +const[{parse:P},{Heap:H},T]=await Promise.all([import('https://esm.sh/smol-toml'),import('https://esm.sh/mnemonist'),import('https://esm.sh/text-table')]); +const d=P(s),e=d.edges||[],q=new H((x,y)=>x.w-y.w),u=new Set; +for(const c of e){q.push({f:c.from,t:c.to,w:c.weight});u.add(c.from);u.add(c.to)} +const n=u.size,a={},b={},f=x=>a[x]===x?x:(a[x]=f(a[x])),m=(x,y)=>{let r=f(x),s=f(y);if(r===s)return 0;if(b[r] [e.from, e.to])); + const parent = {}, rank = {}; + + for (const n of nodes) { + parent[n] = n; + rank[n] = 0; + } + + const find = x => parent[x] === x ? x : (parent[x] = find(parent[x])); + + const union = (a, b) => { + const rootA = find(a), rootB = find(b); + if (rootA === rootB) return false; + if (rank[rootA] < rank[rootB]) parent[rootA] = rootB; + else if (rank[rootA] > rank[rootB]) parent[rootB] = rootA; + else { parent[rootB] = rootA; rank[rootA]++; } + return true; + }; + + const heap = new Heap((a, b) => a.weight - b.weight); + edges.forEach(e => heap.push(e)); + + const mst = []; + let totalWeight = 0; + + while (heap.size) { + const { from, to, weight } = heap.pop(); + if (union(from, to)) { + mst.push([from, to, String(weight)]); + totalWeight += weight; + if (mst.length === nodes.size - 1) break; + } + } + + return { + table: textTable([['From', 'To', 'Weight'], ...mst]), + totalWeight + }; +} +export default computeMST; +// Generation time: 200.325s +// Result: PASS \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/x-ai_grok-4.js b/tests/12_mst_pipeline/outputs/x-ai_grok-4.js new file mode 100644 index 0000000..5f42359 --- /dev/null +++ b/tests/12_mst_pipeline/outputs/x-ai_grok-4.js @@ -0,0 +1,75 @@ +async function computeMST(toml) { + const [smol, mnemo, ttable] = await Promise.all([ + import('https://cdn.jsdelivr.net/npm/smol-toml'), + import('https://cdn.jsdelivr.net/npm/mnemonist'), + import('https://cdn.jsdelivr.net/npm/text-table') + ]); + const {parse} = smol; + const {Heap} = mnemo; + const textTable = ttable.default; + + const config = parse(toml); + const edges = config.edges; + + const nodes = new Set(); + for (const e of edges) { + nodes.add(e.from); + nodes.add(e.to); + } + const numNodes = nodes.size; + + const parent = new Map(); + const rank = new Map(); + for (const node of nodes) { + parent.set(node, node); + rank.set(node, 0); + } + + function find(p, x) { + if (p.get(x) !== x) { + p.set(x, find(p, p.get(x))); + } + return p.get(x); + } + + function union(p, r, x, y) { + let px = find(p, x); + let py = find(p, y); + if (px === py) return false; + if (r.get(px) < r.get(py)) { + p.set(px, py); + } else if (r.get(px) > r.get(py)) { + p.set(py, px); + } else { + p.set(py, px); + r.set(px, r.get(px) + 1); + } + return true; + } + + const edgeHeap = new Heap((a, b) => a.weight - b.weight); + for (const edge of edges) { + edgeHeap.push(edge); + } + + const mst = []; + let totalWeight = 0; + while (mst.length < numNodes - 1 && edgeHeap.size > 0) { + const edge = edgeHeap.pop(); + if (union(parent, rank, edge.from, edge.to)) { + mst.push(edge); + totalWeight += edge.weight; + } + } + + const rows = [['From', 'To', 'Weight']]; + for (const e of mst) { + rows.push([e.from, e.to, String(e.weight)]); + } + + const tableStr = textTable(rows); + return { table: tableStr, totalWeight }; +} +export default computeMST; +// Generation time: 49.564s +// Result: FAIL \ No newline at end of file diff --git a/tests/12_mst_pipeline/outputs/z-ai_glm-4.7.js b/tests/12_mst_pipeline/outputs/z-ai_glm-4.7.js new file mode 100644 index 0000000..c85729f --- /dev/null +++ b/tests/12_mst_pipeline/outputs/z-ai_glm-4.7.js @@ -0,0 +1,52 @@ +async function computeMST(t) { + const [ + { parse: P }, + { Heap: H }, + { default: T } + ] = await Promise.all([ + import('https://esm.sh/smol-toml'), + import('https://esm.sh/mnemonist'), + import('https://esm.sh/text-table') + ]); + + const E = P(t).edges; + const p = new Map(), r = new Map(); + + const f = (x) => { + if (!p.has(x)) { p.set(x, x); r.set(x, 0); return x; } + if (p.get(x) !== x) p.set(x, f(p.get(x))); + return p.get(x); + }; + + const u = (x, y) => { + const a = f(x), b = f(y); + if (a === b) return 0; + if (r.get(a) < r.get(b)) p.set(a, b); + else if (r.get(a) > r.get(b)) p.set(b, a); + else { p.set(b, a); r.set(a, r.get(a) + 1); } + return 1; + }; + + const h = new H((a, b) => a[2] - b[2]); + E.forEach(e => h.push([e.from, e.to, e.weight])); + + const M = []; + let S = 0; + const N = new Set(E.flatMap(e => [e.from, e.to])); + + while (h.size && M.length < N.size - 1) { + const [i, j, w] = h.pop(); + if (u(i, j)) { + M.push([i, j, String(w)]); + S += w; + } + } + + return { + table: T([['From', 'To', 'Weight'], ...M]), + totalWeight: S + }; +} +export default computeMST; +// Generation time: 62.217s +// Result: PASS \ No newline at end of file