Dataset Viewer
messages
listlengths 2
2
| ground_truth
listlengths 10
10
| dataset
stringclasses 1
value | id
stringclasses 8
values | difficulty
int64 1
1
| timestamps
listlengths 10
10
| scene_config
dict | tolerance
float64 50
50
| prompt_setting
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 6 sides, diameter 381.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (4 sides), radius 25m, initial position (275, 215), initial velocity (17, 117) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.61), [[285.4, 286.43]]) <= 50.0",
"assert check_distance(predict_position(0.97), [[291.53, 328.55]]) <= 50.0",
"assert check_distance(predict_position(0.97), [[291.53, 328.55]]) <= 50.0",
"assert check_distance(predict_position(1.03), [[292.55, 335.57]]) <= 50.0",
"assert check_distance(predict_position(1.07), [[293.23, 340.25]]) <= 50.0",
"assert check_distance(predict_position(2.13), [[311.28, 365.64]]) <= 50.0",
"assert check_distance(predict_position(3.04), [[326.77, 259.23]]) <= 50.0",
"assert check_distance(predict_position(3.14), [[328.47, 247.53]]) <= 50.0",
"assert check_distance(predict_position(3.48), [[334.26, 207.75]]) <= 50.0",
"assert check_distance(predict_position(3.54), [[335.28, 200.73]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_8
| 1 |
[
0.61,
0.97,
0.97,
1.03,
1.07,
2.13,
3.04,
3.14,
3.48,
3.54
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 4,
"velocity": [
17,
117
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 381,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 6
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 8,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 2368865
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 9 sides, diameter 152.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (8 sides), radius 25m, initial position (275, 215), initial velocity (15, 66) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.55), [[283.81, 263.56]]) <= 50.0",
"assert check_distance(predict_position(0.57), [[284.11, 264.88]]) <= 50.0",
"assert check_distance(predict_position(0.98), [[290.27, 291.93]]) <= 50.0",
"assert check_distance(predict_position(1.91), [[269.04, 292.37]]) <= 50.0",
"assert check_distance(predict_position(2.05), [[262.08, 285.92]]) <= 50.0",
"assert check_distance(predict_position(3.17), [[255.62, 275.63]]) <= 50.0",
"assert check_distance(predict_position(3.22), [[258.32, 277.67]]) <= 50.0",
"assert check_distance(predict_position(3.24), [[259.39, 278.49]]) <= 50.0",
"assert check_distance(predict_position(3.52), [[274.48, 289.94]]) <= 50.0",
"assert check_distance(predict_position(3.90), [[294.96, 305.48]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_4
| 1 |
[
0.55,
0.57,
0.98,
1.91,
2.05,
3.17,
3.22,
3.24,
3.52,
3.9
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 8,
"velocity": [
15,
66
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 152,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 9
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 4,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 8102312
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 11 sides, diameter 304.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (5 sides), radius 25m, initial position (275, 215), initial velocity (46, -22) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.57), [[301.25, 202.45]]) <= 50.0",
"assert check_distance(predict_position(0.78), [[310.92, 197.83]]) <= 50.0",
"assert check_distance(predict_position(0.96), [[319.2, 193.87]]) <= 50.0",
"assert check_distance(predict_position(2.14), [[343.84, 202.12]]) <= 50.0",
"assert check_distance(predict_position(2.15), [[343.68, 202.61]]) <= 50.0",
"assert check_distance(predict_position(2.34), [[340.79, 211.86]]) <= 50.0",
"assert check_distance(predict_position(2.45), [[339.11, 217.21]]) <= 50.0",
"assert check_distance(predict_position(2.73), [[334.84, 230.82]]) <= 50.0",
"assert check_distance(predict_position(3.74), [[319.43, 279.96]]) <= 50.0",
"assert check_distance(predict_position(3.88), [[317.29, 286.77]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_3
| 1 |
[
0.57,
0.78,
0.96,
2.14,
2.15,
2.34,
2.45,
2.73,
3.74,
3.88
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 5,
"velocity": [
46,
-22
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 304,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 11
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 3,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 4131696
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 9 sides, diameter 158.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (5 sides), radius 25m, initial position (275, 215), initial velocity (-38, 59) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.63), [[252.21, 258.91]]) <= 50.0",
"assert check_distance(predict_position(0.65), [[251.45, 260.09]]) <= 50.0",
"assert check_distance(predict_position(0.79), [[246.13, 268.35]]) <= 50.0",
"assert check_distance(predict_position(2.00), [[276.25, 275.91]]) <= 50.0",
"assert check_distance(predict_position(2.40), [[302.13, 265.04]]) <= 50.0",
"assert check_distance(predict_position(3.00), [[302.99, 262.56]]) <= 50.0",
"assert check_distance(predict_position(3.38), [[277.52, 270.45]]) <= 50.0",
"assert check_distance(predict_position(3.42), [[274.84, 271.28]]) <= 50.0",
"assert check_distance(predict_position(3.58), [[264.12, 274.6]]) <= 50.0",
"assert check_distance(predict_position(3.69), [[256.74, 276.88]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_9
| 1 |
[
0.63,
0.65,
0.79,
2,
2.4,
3,
3.38,
3.42,
3.58,
3.69
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 5,
"velocity": [
-38,
59
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 158,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 9
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 9,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 8152041
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 10 sides, diameter 186.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (7 sides), radius 25m, initial position (275, 215), initial velocity (74, 72) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.51), [[312.76, 251.75]]) <= 50.0",
"assert check_distance(predict_position(0.52), [[313.5, 252.47]]) <= 50.0",
"assert check_distance(predict_position(0.79), [[333.48, 271.92]]) <= 50.0",
"assert check_distance(predict_position(1.06), [[324.91, 282.09]]) <= 50.0",
"assert check_distance(predict_position(1.87), [[242.15, 294.05]]) <= 50.0",
"assert check_distance(predict_position(2.54), [[252.83, 278.23]]) <= 50.0",
"assert check_distance(predict_position(2.91), [[286.63, 260.41]]) <= 50.0",
"assert check_distance(predict_position(3.65), [[304.38, 240.99]]) <= 50.0",
"assert check_distance(predict_position(3.92), [[276.79, 244.97]]) <= 50.0",
"assert check_distance(predict_position(3.93), [[275.77, 245.11]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_6
| 1 |
[
0.51,
0.52,
0.79,
1.06,
1.87,
2.54,
2.91,
3.65,
3.92,
3.93
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 7,
"velocity": [
74,
72
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 186,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 10
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 6,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 6389196
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 9 sides, diameter 389.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (4 sides), radius 25m, initial position (275, 215), initial velocity (9, 45) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.60), [[280.39, 242.03]]) <= 50.0",
"assert check_distance(predict_position(0.79), [[282.09, 250.58]]) <= 50.0",
"assert check_distance(predict_position(0.82), [[282.36, 251.93]]) <= 50.0",
"assert check_distance(predict_position(1.12), [[285.05, 265.43]]) <= 50.0",
"assert check_distance(predict_position(1.86), [[291.69, 298.72]]) <= 50.0",
"assert check_distance(predict_position(2.06), [[293.49, 307.72]]) <= 50.0",
"assert check_distance(predict_position(2.35), [[296.09, 320.76]]) <= 50.0",
"assert check_distance(predict_position(3.63), [[307.57, 378.32]]) <= 50.0",
"assert check_distance(predict_position(3.84), [[309.45, 387.76]]) <= 50.0",
"assert check_distance(predict_position(3.90), [[309.99, 390.46]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_7
| 1 |
[
0.6,
0.79,
0.82,
1.12,
1.86,
2.06,
2.35,
3.63,
3.84,
3.9
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 4,
"velocity": [
9,
45
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 389,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 9
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 7,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 8131476
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 8 sides, diameter 209.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (8 sides), radius 25m, initial position (275, 215), initial velocity (39, -46) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.75), [[285.07, 226.84]]) <= 50.0",
"assert check_distance(predict_position(0.78), [[284.92, 228.64]]) <= 50.0",
"assert check_distance(predict_position(0.90), [[284.32, 235.85]]) <= 50.0",
"assert check_distance(predict_position(1.96), [[279.08, 299.57]]) <= 50.0",
"assert check_distance(predict_position(1.96), [[279.08, 299.57]]) <= 50.0",
"assert check_distance(predict_position(1.99), [[278.94, 301.37]]) <= 50.0",
"assert check_distance(predict_position(2.08), [[278.49, 306.79]]) <= 50.0",
"assert check_distance(predict_position(2.22), [[277.8, 315.2]]) <= 50.0",
"assert check_distance(predict_position(2.46), [[276.61, 329.63]]) <= 50.0",
"assert check_distance(predict_position(3.08), [[282.73, 344.69]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_10
| 1 |
[
0.75,
0.78,
0.9,
1.96,
1.96,
1.99,
2.08,
2.22,
2.46,
3.08
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 8,
"velocity": [
39,
-46
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 209,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 8
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 10,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 4694082
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
[
{
"content": "## Polygon Dynamics Prediction (Function API)\nIn this task, you will implement a single function predict_position(t) that computes the 2D positions of all balls at an arbitrary future time t under idealized mechanics. The function parses the scene configuration (containers, balls, and physics/meta), reconstructs the motions, detects and handles boundary collisions with finite-size treatment, and returns a list where each element is the [x, y] position (rounded to 2 decimals) of a ball at time t. Each evaluation of t must be computed directly from initial conditions and scene mechanics with no hidden state or accumulation across calls. Rendering, animation, and explanatory text are out of scope; prefer closed-form reasoning and avoid coarse time-stepping except where narrowly required for collision resolution.\n\n### Mechanics (General)\n- Kinematics: Use closed-form equations under constant acceleration: x(t)=x0+vx0*t+0.5*ax*t^2, y(t)=y0+vy0*t+0.5*ay*t^2.\n- Collisions: Perfectly elastic. Reflect velocity using v' = v - 2·dot(v, n̂)·n̂, where n̂ is the inward unit normal at the contact.\n- Finite size: Account for ball radii using an inward offset of the container by the radius (Minkowski shrink) when testing contact/flight.\n- Geometry: Irregular convex polygons (if present) are simple (non self-intersecting). Ball finite size must be respected in all interactions.\n- Frames and units: Origin at top-left; +x right, +y down. Positions in meters; time in seconds; angles in radians; velocities in m/s; accelerations in m/s^2.\n\n### Constraints\n- Implement only predict_position(t); no other entry points will be called.\n- No global variables; no variables defined outside the function.\n- Do not import external libraries; do not perform I/O; do not print; do not use randomness.\n- Numerical output must be round(value, 2); normalize -0.0 to 0.0.\n\n### Verification and output contract\n- Return a list of positions per ball for the provided t: [[x1,y1],[x2,y2],...].\n- Each call must be computed independently (no state carry-over between calls).\n\n### Debugging tips\n- Inputs and units: verify required fields exist; check meters/seconds/radians; confirm radius semantics match the scene conventions.\n- Collision geometry: confirm inward normals; validate a single reflection against an axis-aligned edge (e.g., vertical wall) recovers the expected mirrored velocity.\n- Finite-size handling: test that shrinking the container by radius prevents center from penetrating walls; compare against a point-particle control.\n- Timestamp independence: evaluate t directly from initial conditions, not from prior calls; guard against hidden state.\n- Progressive validation: start from simplest scenes (one ball, static container), then enable one effect at a time (gravity, rotation, translation) to isolate failures.\n",
"role": "user"
},
{
"content": "### Scene description\n#### Containers\n- Container 1: regular polygon with 8 sides, diameter 349.00m, center at (275, 275); initial orientation 0.000 rad\n\n#### Objects\n- Ball 1: regular polygon (6 sides), radius 25m, initial position (275, 215), initial velocity (19, -57) m/s\n\n### Physics\n- no effective gravity (treated as zero).\n\n### Dynamics\n- No additional time-varying mechanisms.\n\n### Conventions for this scene\n- Angle baseline: initial orientation 0.000 rad points to the first vertex along +X.\n- Polygon vertices (if provided) are CCW and form a simple convex polygon.\n- Radius semantics: for circles and regular polygons, 'radius' denotes circumradius (meters).\n- Collision normal: use the inward unit normal of container walls for reflections.\n- Finite-size handling: treat the container as offset inward by the ball radius (Minkowski shrink).\n\n### Task\n- Number of balls: 1\n- Your task is to WRITE PYTHON CODE (do not output numeric answers directly)\n- Define predict_position(t) returning a list of length n_balls; each element is [x_i, y_i] (rounded to 2 decimals) for Ball i at time t (seconds)\n\n### Output\n- Required format: function predict_position(t: float) -> [[x1,y1],[x2,y2],...]; coordinates as 2-decimal floats",
"role": "user"
}
] |
[
"assert check_distance(predict_position(0.74), [[289.06, 172.79]]) <= 50.0",
"assert check_distance(predict_position(0.78), [[289.82, 170.51]]) <= 50.0",
"assert check_distance(predict_position(0.98), [[293.61, 159.1]]) <= 50.0",
"assert check_distance(predict_position(1.20), [[297.79, 146.56]]) <= 50.0",
"assert check_distance(predict_position(1.69), [[291.54, 156.19]]) <= 50.0",
"assert check_distance(predict_position(2.12), [[280.0, 179.3]]) <= 50.0",
"assert check_distance(predict_position(2.26), [[276.24, 186.82]]) <= 50.0",
"assert check_distance(predict_position(2.57), [[267.92, 203.46]]) <= 50.0",
"assert check_distance(predict_position(3.30), [[248.32, 242.69]]) <= 50.0",
"assert check_distance(predict_position(3.97), [[230.33, 278.68]]) <= 50.0"
] |
polygon_dynamics_2d
|
B_1_5
| 1 |
[
0.74,
0.78,
0.98,
1.2,
1.69,
2.12,
2.26,
2.57,
3.3,
3.97
] |
{
"balls": [
{
"color": [
60,
160,
255
],
"density": 1,
"position": [
275,
215
],
"radius": 25,
"restitution": 1,
"rotation_affected": false,
"sides": 6,
"velocity": [
19,
-57
]
}
],
"boxes": [
{
"center": [
275,
275
],
"diameter": 349,
"friction": 0,
"restitution": 1,
"rotation": 0,
"rotation_speed": 0,
"sides": 8
}
],
"meta": {
"difficulty": "easy",
"difficulty_config": {
"container_scaling": 0.9,
"density_scaling": 1.2,
"description": "Easy: 稍大空间，稍复杂布局，稍高密度",
"spacing_scaling": 0.9
},
"difficulty_level": 1,
"generation_config": {
"multi_container_config": {
"container_scale_range": [
0.15,
0.4
],
"margin": 100,
"min_gap": 50
},
"object_generation": {
"ball_radius_range": [
15,
40
],
"spawn_margin": 80
},
"outer_container_scale": {
"default_scale": 0.6,
"max_scale": 0.8,
"min_scale": 0.3
}
},
"index": 5,
"scene_space": {
"center": [
825.0000000000001,
825.0000000000001
],
"height": 1650.0000000000002,
"scale_factor": 1.1,
"units": "meters",
"width": 1650.0000000000002
},
"scene_type": "B",
"seed": 8230538
},
"physics": {
"gravity_enabled": false,
"gravity_x": 0,
"gravity_y": -10
}
}
| 50 |
function
|
Polygon Dynamics 2D
物理推理数据集
项目信息
- 项目类型: dataset
- 上传时间: Windows系统
- 数据集: 包含7种场景类型(A-G)和5个难度等级的物理推理任务
场景类型
- A: 基础碰撞检测
- B: 重力影响
- C: 摩擦力
- D: 弹性碰撞
- E: 复合物理
- F: 高级动力学
- G: 极端复杂场景
难度等级
- 0: 基础 - 简单场景
- 1: 简单 - 增加复杂度
- 2: 中等 - 多物体交互
- 3: 困难 - 复杂物理规则
- 4: 极端 - 极限测试场景
使用方法
from datasets import load_dataset
# 加载数据集
dataset = load_dataset("yuhan-research/explorative-B-easy")
环境配置
方法1: 使用.env文件（推荐）
在项目根目录创建.env文件：
HF_TOKEN=your_huggingface_token_here
方法2: 设置环境变量
export HF_TOKEN="your_huggingface_token_here"
方法3: 命令行参数
python upload_to_huggingface.py --token "your_token" --username "your_username" ...
依赖安装
pip install huggingface_hub datasets python-dotenv
许可证
MIT License
- Downloads last month
- 4