Dataset Viewer
row_uuid
string | dataset_uuid
string | dataset_name
string | dataset_description
string | keywords
list | preferred_score
string | metrics
list | question_template
string | question_template_input
string | answer
string | compute_function
string | image
image |
|---|---|---|---|---|---|---|---|---|---|---|---|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-15
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[1, 1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 1, 0, 1], [0, 1, 0, 0, 0, 0, 0, 1, 0, 1], [0, 1, 0, 1, 0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 1, 1, 1, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 1]], "start": [6, 8], "end": [3, 5]}
|
10
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-9
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[1, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 1, 0, 0, 1], [1, 1, 0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0, 0, 1], [0, 1, 1, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 1], [0, 1, 1, 0, 1, 0, 1, 0, 1, 0]], "start": [6, 6], "end": [0, 2]}
|
10
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-14
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[1, 1, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 1, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 1, 1, 0, 1, 0, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0, 1, 0, 1]], "start": [3, 5], "end": [7, 6]}
|
9
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-7
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 1, 1, 1, 0], [0, 1, 1, 1, 1, 0, 1, 0, 1, 0], [0, 1, 0, 1, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 1, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 1, 0, 0, 1]], "start": [6, 3], "end": [6, 6]}
|
5
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-12
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0, 1, 1], [1, 0, 1, 0, 0, 0, 1, 1, 0, 1], [1, 0, 0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0, 0, 1, 0], [0, 1, 0, 1, 0, 0, 0, 1, 0, 0]], "start": [7, 3], "end": [0, 7]}
|
11
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-10
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 1, 1, 1, 0, 1, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 1, 1, 0], [1, 0, 0, 0, 0, 1, 1, 0, 0, 0], [1, 0, 1, 0, 1, 0, 0, 0, 1, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 1, 1, 0, 0, 0, 1, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "start": [1, 0], "end": [2, 2]}
|
3
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-6
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 1, 1, 0, 0, 0, 0, 1, 0], [0, 0, 0, 1, 1, 1, 0, 0, 0, 0], [1, 1, 0, 1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 1, 1, 1, 1], [1, 0, 0, 0, 1, 0, 1, 0, 0, 0], [1, 0, 1, 1, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 1, 1, 0, 0, 0, 0]], "start": [8, 6], "end": [4, 5]}
|
5
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-19
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 1, 0, 0, 1, 1, 0, 0, 0, 1], [1, 0, 1, 1, 0, 0, 0, 1, 0, 0], [1, 0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 1, 1, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0, 1, 0, 0], [1, 0, 0, 0, 0, 1, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 1, 0, 0, 0], [1, 0, 1, 0, 0, 0, 1, 0, 0, 0]], "start": [9, 8], "end": [0, 7]}
|
12
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-3
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[1, 0, 0, 0, 1, 0, 0, 1, 1, 0], [1, 0, 0, 0, 0, 1, 0, 0, 0, 0], [1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 1, 0, 1, 0, 0], [1, 0, 1, 1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 1, 0, 0, 1, 0], [1, 0, 1, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 1, 1, 0, 1]], "start": [1, 1], "end": [9, 1]}
|
18
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-0
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 0, 1, 0, 0, 0, 0, 1, 1], [1, 1, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0, 0, 1], [1, 0, 0, 1, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 1, 0, 0, 0, 1, 0], [1, 0, 0, 0, 0, 1, 0, 0, 0, 1]], "start": [8, 6], "end": [2, 3]}
|
13
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-16
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[1, 1, 1, 0, 0, 1, 0, 0, 0, 0], [1, 1, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 1, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 1, 1, 0, 1], [1, 1, 1, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0, 0, 0, 1, 0]], "start": [6, 9], "end": [9, 7]}
|
5
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-5
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 1, 0, 0, 1, 0, 0, 1, 1, 0], [0, 1, 0, 1, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 1, 0, 0, 0, 1, 1, 0], [1, 0, 0, 0, 1, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 1, 0, 0, 1], [0, 1, 1, 1, 0, 1, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "start": [3, 1], "end": [6, 2]}
|
4
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-11
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 1, 0, 0, 1, 1, 0], [1, 1, 0, 0, 1, 0, 1, 1, 0, 0], [1, 1, 0, 0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0, 1, 0, 1], [0, 1, 0, 0, 0, 0, 0, 0, 1, 1]], "start": [3, 9], "end": [3, 3]}
|
8
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-18
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 1, 1, 0, 0, 1, 1, 0, 0, 0], [0, 1, 1, 0, 1, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 0, 1, 0, 1, 0], [1, 0, 0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 1], [1, 0, 1, 1, 0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0, 0, 1, 1, 1], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0, 1, 1]], "start": [6, 6], "end": [7, 5]}
|
2
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
| |
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10-2
|
401d4e49-afb8-4fad-b0b6-1a55c9da1a53-multimodal-grid10
|
diffusion_path_multimodal_grid10
|
Find shortest path on a 10x10 grid (multimodal version).
|
[
"computer science",
"pathfinding",
"BFS",
"grid",
"algorithmic reasoning",
"materials science",
"diffusion",
"multimodal"
] |
exact_str_match
|
[
"exact_str_match"
] |
The image {{entry1}} shows a grid representing a crystal surface where 0 is a walkable site and 1 is an impassable defect. An atom must move from the start coordinate {{start}} to the end coordinate {{end}}. What is the length of the shortest possible path? Movement is restricted to up, down, left, or right steps. If no path exists, the answer is -1.
|
{"grid": [[0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 1, 1, 0, 0, 1, 0], [0, 1, 1, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0, 0, 0, 0], [1, 1, 0, 1, 1, 0, 0, 0, 1, 1], [1, 1, 0, 1, 0, 1, 0, 0, 0, 0], [0, 1, 1, 0, 1, 0, 0, 1, 0, 1]], "start": [4, 9], "end": [0, 1]}
|
12
|
import collections
def calculate_solution(template_input: dict) -> str:
"""
Finds the length of the shortest path in a grid from start to end
using the Breadth-First Search (BFS) algorithm.
"""
grid = template_input['grid']
start = tuple(template_input['start'])
end = tuple(template_input['end'])
rows, cols = len(grid), len(grid[0])
# Check if start or end are on an obstacle
if grid[start[0]][start[1]] == 1 or grid[end[0]][end[1]] == 1:
return "-1"
# Queue for BFS: (row, col, distance)
queue = collections.deque([(start[0], start[1], 0)])
# Set to keep track of visited cells
visited = {start}
while queue:
r, c, dist = queue.popleft()
# If we reached the end, return the distance
if (r, c) == end:
return str(dist)
# Explore neighbors (up, down, left, right)
for dr, dc in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
nr, nc = r + dr, c + dc
# Check for valid next step
if (0 <= nr < rows and
0 <= nc < cols and
grid[nr][nc] == 0 and
(nr, nc) not in visited):
visited.add((nr, nc))
queue.append((nr, nc, dist + 1))
# If the queue empties and we haven't found the end, it's unreachable
return "-1"
|
### Configuration: `particel_energy_2d`
This configuration contains text-only problems for calculating the total energy of a 2D particle system.
**Task Description:**
Calculate the total energy of a system with 10 particles in a 10x10 Angstrom box. The energy calculation involves:
1. **Particle Energy**: The individual energy of each particle.
2. **Pairwise Interaction Energy**: For particles within a 5 Angstrom cutoff distance, the interaction energy is `distance * (energy_A + energy_B)`.
**Data Fields:**
- `uuid`: A unique identifier for the example.
- `input`: The question text describing the particle system's coordinates and energies.
- `target`: The numerical answer for the total energy in eV.
- ... (and other relevant metadata fields).
**Usage:**
```python
from datasets import load_dataset
dataset = load_dataset("n0w0f/scirex-text", name="particel_energy_2d", split="train")
print(dataset[0])
Configuration: particle_energy_2d
Type: Multimodal Examples: 20 Task: Energy computation for 2D particle systems
Description: Calculate the total energy of a system with 10 particles in a 10×10 Angstrom box. The energy calculation involves:
- Particle Energy: Individual energy contribution from each particle
- Pairwise Interaction Energy: For particles within 5 Angstrom cutoff, interaction energy = distance × (energy_A + energy_B)
Usage:
from datasets import load_dataset
dataset = load_dataset("particle_energy_computation_multimodal", name="particle_energy_2d")
example = dataset['train'][0]
print(example)
Data Fields:
uuid: Unique identifierexamples: Problem data (JSON string)description: Task descriptionimage: Visualization of particle systemOther metadata fields
--- ## Configuration: `particle_energy_multimodal_3d_n25` **Description**: Calculate total energy of 25 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n5` **Description**: Calculate total energy of 5 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n5` **Description**: Calculate total energy of 5 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n25` **Description**: Calculate total energy of 25 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n10` **Description**: Calculate total energy of 10 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n50` **Description**: Calculate total energy of 50 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n10` **Description**: Calculate total energy of 10 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n50` **Description**: Calculate total energy of 50 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n25` **Description**: Calculate total energy of 25 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n5` **Description**: Calculate total energy of 5 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n5` **Description**: Calculate total energy of 5 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n25` **Description**: Calculate total energy of 25 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n10` **Description**: Calculate total energy of 10 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_2d_n50` **Description**: Calculate total energy of 50 2D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `2d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_2d_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n10` **Description**: Calculate total energy of 10 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `particle_energy_multimodal_3d_n50` **Description**: Calculate total energy of 50 3D particles (multimodal version). **Number of Examples**: 15 **Keywords**: `physics`, `computational chemistry`, `energy`, `particles`, `pairwise-interactions`, `3d-systems`, `numerical-reasoning`, `multimodal`, `visualization` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="particle_energy_multimodal_3d_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `peak_sorting_multimodal_n100` **Description**: Sort a list of 100 spectral peaks by position or intensity (multimodal version). **Number of Examples**: 15 **Keywords**: `data processing`, `sorting`, `spectroscopy`, `analytical chemistry`, `list manipulation`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="peak_sorting_multimodal_n100") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `peak_sorting_multimodal_n25` **Description**: Sort a list of 25 spectral peaks by position or intensity (multimodal version). **Number of Examples**: 15 **Keywords**: `data processing`, `sorting`, `spectroscopy`, `analytical chemistry`, `list manipulation`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="peak_sorting_multimodal_n25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `peak_sorting_multimodal_n10` **Description**: Sort a list of 10 spectral peaks by position or intensity (multimodal version). **Number of Examples**: 15 **Keywords**: `data processing`, `sorting`, `spectroscopy`, `analytical chemistry`, `list manipulation`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="peak_sorting_multimodal_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `peak_sorting_multimodal_n50` **Description**: Sort a list of 50 spectral peaks by position or intensity (multimodal version). **Number of Examples**: 15 **Keywords**: `data processing`, `sorting`, `spectroscopy`, `analytical chemistry`, `list manipulation`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="peak_sorting_multimodal_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `peak_sorting_multimodal_n5` **Description**: Sort a list of 5 spectral peaks by position or intensity (multimodal version). **Number of Examples**: 15 **Keywords**: `data processing`, `sorting`, `spectroscopy`, `analytical chemistry`, `list manipulation`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="peak_sorting_multimodal_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `diffusion_path_multimodal_grid50` **Description**: Find shortest path on a 50x50 grid (multimodal version). **Number of Examples**: 20 **Keywords**: `computer science`, `pathfinding`, `BFS`, `grid`, `algorithmic reasoning`, `materials science`, `diffusion`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="diffusion_path_multimodal_grid50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `diffusion_path_multimodal_grid10` **Description**: Find shortest path on a 10x10 grid (multimodal version). **Number of Examples**: 20 **Keywords**: `computer science`, `pathfinding`, `BFS`, `grid`, `algorithmic reasoning`, `materials science`, `diffusion`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="diffusion_path_multimodal_grid10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `diffusion_path_multimodal_grid25` **Description**: Find shortest path on a 25x25 grid (multimodal version). **Number of Examples**: 20 **Keywords**: `computer science`, `pathfinding`, `BFS`, `grid`, `algorithmic reasoning`, `materials science`, `diffusion`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="diffusion_path_multimodal_grid25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `diffusion_path_multimodal_grid5` **Description**: Find shortest path on a 5x5 grid (multimodal version). **Number of Examples**: 20 **Keywords**: `computer science`, `pathfinding`, `BFS`, `grid`, `algorithmic reasoning`, `materials science`, `diffusion`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="diffusion_path_multimodal_grid5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `fsm_traversal_multimodal_len5` **Description**: Traverse a 4-state FSM with an input string of length 5 (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `FSM`, `finite state machine`, `automata theory`, `algorithmic reasoning`, `rule-following`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="fsm_traversal_multimodal_len5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `fsm_traversal_multimodal_len25` **Description**: Traverse a 4-state FSM with an input string of length 25 (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `FSM`, `finite state machine`, `automata theory`, `algorithmic reasoning`, `rule-following`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="fsm_traversal_multimodal_len25") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `fsm_traversal_multimodal_len10` **Description**: Traverse a 4-state FSM with an input string of length 10 (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `FSM`, `finite state machine`, `automata theory`, `algorithmic reasoning`, `rule-following`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="fsm_traversal_multimodal_len10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `fsm_traversal_multimodal_len50` **Description**: Traverse a 4-state FSM with an input string of length 50 (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `FSM`, `finite state machine`, `automata theory`, `algorithmic reasoning`, `rule-following`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="fsm_traversal_multimodal_len50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `tree_traversal_multimodal_n5` **Description**: Perform a traversal on a binary tree with 5 nodes (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `data structures`, `binary tree`, `recursion`, `algorithmic reasoning`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="tree_traversal_multimodal_n5") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `tree_traversal_multimodal_n50` **Description**: Perform a traversal on a binary tree with 50 nodes (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `data structures`, `binary tree`, `recursion`, `algorithmic reasoning`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="tree_traversal_multimodal_n50") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `tree_traversal_multimodal_n10` **Description**: Perform a traversal on a binary tree with 10 nodes (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `data structures`, `binary tree`, `recursion`, `algorithmic reasoning`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="tree_traversal_multimodal_n10") # Access the first example example = dataset['train'] print(example) --- ## Configuration: `tree_traversal_multimodal_n25` **Description**: Perform a traversal on a binary tree with 25 nodes (multimodal version). **Number of Examples**: 15 **Keywords**: `computer science`, `data structures`, `binary tree`, `recursion`, `algorithmic reasoning`, `multimodal` **Usage:**```python from datasets import load_dataset # Load this specific configuration dataset = load_dataset("n0w0f/scirex-image", name="tree_traversal_multimodal_n25") # Access the first example example = dataset['train'] print(example)
- Downloads last month
- 43