diff --git a/README b/README index a2d8ff9..e0eb42d 100644 --- a/README +++ b/README @@ -27,9 +27,9 @@ openai/gpt-5-codex The table below shows the pass/fail status for each model on each test. - Model | 1_dijkstra | 2_convex_hull | 3_lis | 4_determinant - ----------------------------|------------|---------------|---------|--------------- - google/gemini-2.5-pro | ❌ Fail | ❌ Fail | ❌ Fail | ❌ Fail - anthropic/claude-sonnet-4.5 | ❌ Fail | ❌ Fail | ❌ Fail | ❌ Fail - openai/gpt-5-codex | ❌ Fail | ❌ Fail | ❌ Fail | ❌ Fail + Model | 1_dijkstra | 2_convex_hull | 3_lis | 4_determinant + --------------------------- | ---------- | ------------- | --------- | ------------- + google/gemini-2.5-pro | ❌ Fail | ⚪ Not Run | ⚪ Not Run | ⚪ Not Run + anthropic/claude-sonnet-4.5 | ❌ Fail | ⚪ Not Run | ⚪ Not Run | ⚪ Not Run + openai/gpt-5-codex | ❌ Fail | ⚪ Not Run | ⚪ Not Run | ⚪ Not Run diff --git a/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js new file mode 100644 index 0000000..b6b93bc --- /dev/null +++ b/tests/1_dijkstra/outputs/anthropic_claude-sonnet-4.5_2025-10-13T12-57-53.824Z.js @@ -0,0 +1,82 @@ +async function findShortestPath(graph, start, end) { + // Dynamically import the priority queue library from CDN + const { default: PriorityQueue } = await import( + 'https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm' + ); + + // Initialize distances object with Infinity for all nodes + const distances = {}; + for (const node in graph) { + distances[node] = Infinity; + } + distances[start] = 0; + + // Initialize visited set + const visited = new Set(); + + // Create a min-priority queue (lower distance = higher priority) + const pq = new PriorityQueue({ + comparator: (a, b) => a.distance - b.distance + }); + + // Add start node to priority queue + pq.queue({ node: start, distance: 0 }); + + while (pq.length > 0) { + const { node: currentNode, distance: currentDistance } = pq.dequeue(); + + // Skip if already visited + if (visited.has(currentNode)) { + continue; + } + + // Mark as visited + visited.add(currentNode); + + // If we reached the end node, return the distance + if (currentNode === end) { + return currentDistance; + } + + // Skip if current distance is outdated + if (currentDistance > distances[currentNode]) { + continue; + } + + // Check all neighbors + const neighbors = graph[currentNode] || {}; + for (const neighbor in neighbors) { + if (visited.has(neighbor)) { + continue; + } + + const weight = neighbors[neighbor]; + const newDistance = currentDistance + weight; + + // If we found a shorter path, update it + if (newDistance < distances[neighbor]) { + distances[neighbor] = newDistance; + pq.queue({ node: neighbor, distance: newDistance }); + } + } + } + + // If we get here, no path exists + return Infinity; +} + +// Example usage: +(async () => { + const graph = { + 'A': { 'B': 1, 'C': 4 }, + 'B': { 'A': 1, 'C': 2, 'D': 5 }, + 'C': { 'A': 4, 'B': 2, 'D': 1 }, + 'D': { 'B': 5, 'C': 1 } + }; + + const shortestPath = await findShortestPath(graph, 'A', 'D'); + console.log('Shortest path from A to D:', shortestPath); // Output: 4 + + const noPath = await findShortestPath(graph, 'A', 'E'); + console.log('Path from A to E (non-existent):', noPath); // Output: Infinity +})(); \ No newline at end of file diff --git a/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js new file mode 100644 index 0000000..48f930a --- /dev/null +++ b/tests/1_dijkstra/outputs/google_gemini-2.5-pro_2025-10-13T12-57-41.842Z.js @@ -0,0 +1,120 @@ +/** + * Finds the shortest path in a weighted, undirected graph using Dijkstra's algorithm. + * + * This function dynamically imports the 'js-priority-queue' library to manage nodes to visit. + * + * @param {object} graph - The graph structure. e.g., { 'A': { 'B': 1, 'C': 4 }, 'B': { ... }, ... } + * @param {string} startNode - The starting node. + * @param {string} endNode - The ending node. + * @returns {Promise} The total weight of the shortest path, or Infinity if no path exists. + */ +async function findShortestPath(graph, startNode, endNode) { + let PriorityQueue; + try { + // Dynamically import the PriorityQueue library from a CDN. + // The { default: ... } syntax is used to get the default export from the UMD module. + const PQLib = await import('https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/priority-queue.min.js'); + PriorityQueue = PQLib.default; + } catch (e) { + console.error("Failed to load the Priority Queue library from the CDN.", e); + // Can't proceed without the library. + throw new Error("Could not load a required dependency."); + } + + // 1. Initialize distances, priority queue, and previous nodes map + const distances = {}; + const priorityQueue = new PriorityQueue({ + // The comparator ensures the queue is a min-priority queue based on distance. + comparator: (a, b) => a.distance - b.distance + }); + + // Set initial distances for all nodes + for (const node in graph) { + if (node === startNode) { + distances[node] = 0; + priorityQueue.queue({ node: node, distance: 0 }); + } else { + distances[node] = Infinity; + } + } + + // If the start or end node is not in the graph, no path can exist. + if (distances[startNode] === undefined || distances[endNode] === undefined) { + return Infinity; + } + + + // 2. Main loop of Dijkstra's algorithm + while (priorityQueue.length > 0) { + // Get the node with the smallest distance from the queue + const { node: currentNode, distance: currentDistance } = priorityQueue.dequeue(); + + // If we've already found a shorter path to the current node, skip it. + if (currentDistance > distances[currentNode]) { + continue; + } + + // If we've reached the end node, we have found the shortest path. + if (currentNode === endNode) { + // The value in 'distances' is the shortest path weight. + return distances[endNode]; + } + + const neighbors = graph[currentNode]; + if (!neighbors) continue; // Skip if node has no outgoing edges + + // 3. Relaxation step: Check all neighbors of the current node + for (const neighbor in neighbors) { + const weight = neighbors[neighbor]; + const distanceThroughCurrent = currentDistance + weight; + + // If we found a shorter path to the neighbor, update it. + if (distanceThroughCurrent < distances[neighbor]) { + distances[neighbor] = distanceThroughCurrent; + // Enqueue the neighbor with its new, shorter distance. + priorityQueue.queue({ node: neighbor, distance: distanceThroughCurrent }); + } + } + } + + // 4. If the loop finishes and we haven't returned, the end node is unreachable. + return distances[endNode]; // This will be Infinity +} + + +// --- Example Usage --- + +// Define the graph structure +const graph = { + 'A': { 'B': 2, 'C': 5 }, + 'B': { 'A': 2, 'C': 6, 'D': 1 }, + 'C': { 'A': 5, 'B': 6, 'D': 6, 'E': 8 }, + 'D': { 'B': 1, 'C': 6, 'E': 2 }, + 'E': { 'C': 8, 'D': 2 }, + 'F': { 'G': 1 }, // A disconnected part of the graph + 'G': { 'F': 1 } +}; + +// We wrap the calls in an async IIFE (Immediately Invoked Function Expression) +// because we can only use 'await' inside an async function. +(async () => { + console.log("Finding shortest path from A to E..."); + const pathAtoE = await findShortestPath(graph, 'A', 'E'); + console.log(`Shortest path from A to E has a weight of: ${pathAtoE}`); // Expected: 5 (A -> B -> D -> E) + + console.log("\nFinding shortest path from A to C..."); + const pathAtoC = await findShortestPath(graph, 'A', 'C'); + console.log(`Shortest path from A to C has a weight of: ${pathAtoC}`); // Expected: 5 (A -> C) + + console.log("\nFinding shortest path from A to A..."); + const pathAtoA = await findShortestPath(graph, 'A', 'A'); + console.log(`Shortest path from A to A has a weight of: ${pathAtoA}`); // Expected: 0 + + console.log("\nFinding shortest path from A to F (unreachable)..."); + const pathAtoF = await findShortestPath(graph, 'A', 'F'); + console.log(`Shortest path from A to F has a weight of: ${pathAtoF}`); // Expected: Infinity + + console.log("\nFinding shortest path from A to Z (non-existent node)..."); + const pathAtoZ = await findShortestPath(graph, 'A', 'Z'); + console.log(`Shortest path from A to Z has a weight of: ${pathAtoZ}`); // Expected: Infinity +})(); \ No newline at end of file diff --git a/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js new file mode 100644 index 0000000..abc0844 --- /dev/null +++ b/tests/1_dijkstra/outputs/openai_gpt-5-codex_2025-10-13T12-58-10.965Z.js @@ -0,0 +1,71 @@ +// Lazy-load the PriorityQueue module once and cache the Promise +let priorityQueueModulePromise; + +/** + * Asynchronously finds the total weight of the shortest path between two nodes + * in a weighted, undirected graph using Dijkstra's algorithm. + * + * @param {Object>} graph - Adjacency list representation of the graph. + * @param {string} start - The starting node. + * @param {string} end - The destination node. + * @returns {Promise} Total weight of the shortest path or Infinity if no path exists. + */ +export async function findShortestPath(graph, start, end) { + if (!graph || graph[start] === undefined || graph[end] === undefined) { + return Infinity; + } + if (start === end) { + return 0; + } + + // Dynamically import js-priority-queue from a CDN (via jsDelivr +esm build) + if (!priorityQueueModulePromise) { + priorityQueueModulePromise = import( + 'https://cdn.jsdelivr.net/npm/js-priority-queue@0.1.5/+esm' + ); + } + + const { default: PriorityQueue } = await priorityQueueModulePromise; + + const distances = Object.create(null); + const visited = new Set(); + + // Initialize distances + for (const node of Object.keys(graph)) { + distances[node] = Infinity; + } + distances[start] = 0; + + const queue = new PriorityQueue({ + comparator: (a, b) => a.distance - b.distance, + }); + + queue.queue({ node: start, distance: 0 }); + + while (queue.length > 0) { + const { node: currentNode, distance: currentDistance } = queue.dequeue(); + + if (visited.has(currentNode)) { + continue; + } + visited.add(currentNode); + + if (currentNode === end) { + return currentDistance; + } + + const neighbors = graph[currentNode] || {}; + for (const [neighbor, weight] of Object.entries(neighbors)) { + if (weight < 0) { + throw new Error('Dijkstra\'s algorithm requires non-negative edge weights.'); + } + const newDistance = currentDistance + weight; + if (newDistance < distances[neighbor]) { + distances[neighbor] = newDistance; + queue.queue({ node: neighbor, distance: newDistance }); + } + } + } + + return Infinity; +} \ No newline at end of file