Dataset Viewer
messages
list | ground_truth
list | dataset
string | difficulty
string | id
string | problem_family
string | name
string |
|---|---|---|---|---|---|---|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with RB, then put 'RRR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RRR'",
"expected_accepted": true,
"expected_output": "RRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRRR'",
"expected_accepted": true,
"expected_output": "RRRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRRRB'",
"expected_accepted": true,
"expected_output": "RRRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RRRBBR'",
"expected_accepted": true,
"expected_output": "RRRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RBB' → output: 'RRRRBB'",
"expected_accepted": true,
"expected_output": "RRRRBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RB' → output: 'RRRRB'",
"expected_accepted": true,
"expected_output": "RRRRB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RRRBR'",
"expected_accepted": true,
"expected_output": "RRRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RRRBRB'",
"expected_accepted": true,
"expected_output": "RRRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RRRBB'",
"expected_accepted": true,
"expected_output": "RRRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RRRBRBR'",
"expected_accepted": true,
"expected_output": "RRRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RRRBBB'",
"expected_accepted": true,
"expected_output": "RRRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RBR' → output: 'RRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RRRRBRB'",
"expected_accepted": true,
"expected_output": "RRRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BRBRRRRB' → mutated: 'BRBRBRBB' → output: 'RRRBRBRBRBB'",
"expected_accepted": true,
"expected_output": "RRRBRBRBRBB",
"input": "BRBRRRRB"
},
{
"check_output": true,
"description": "Input 'RRRRRBRRRBBB' → mutated: 'RBRBRBRBRBBB' → output: 'RRRRBRBRBRBRBBB'",
"expected_accepted": true,
"expected_output": "RRRRBRBRBRBRBBB",
"input": "RRRRRBRRRBBB"
}
] |
manufactoria
|
hard
|
1b2fa0c2-677f-49a6-bd97-fa72092c22d6
|
prepend_sequence
|
Prepend RRR after Replace patterns RR with RB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with BR, then put 'BBBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BBBRRB'",
"expected_accepted": true,
"expected_output": "BBBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBBRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BBBRRBR'",
"expected_accepted": true,
"expected_output": "BBBRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'BRB' → output: 'BBBRBRB'",
"expected_accepted": true,
"expected_output": "BBBRBRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'BR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BBBRBRB'",
"expected_accepted": true,
"expected_output": "BBBRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBBRBB'",
"expected_accepted": true,
"expected_output": "BBBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BRBB' → mutated: 'BRBB' → output: 'BBBRBRBB'",
"expected_accepted": true,
"expected_output": "BBBRBRBB",
"input": "BRBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBBRBBB'",
"expected_accepted": true,
"expected_output": "BBBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'BRR' → output: 'BBBRBRR'",
"expected_accepted": true,
"expected_output": "BBBRBRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BBBRBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BBBRRBRB'",
"expected_accepted": true,
"expected_output": "BBBRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBBRRBBR' → mutated: 'BBBBRBBR' → output: 'BBBRBBBBRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBBBRBBR",
"input": "BBBRRBBR"
},
{
"check_output": true,
"description": "Input 'BBBBRRBBBRRR' → mutated: 'BBBBBRBBBBRR' → output: 'BBBRBBBBBRBBBBRR'",
"expected_accepted": true,
"expected_output": "BBBRBBBBBRBBBBRR",
"input": "BBBBRRBBBRRR"
}
] |
manufactoria
|
hard
|
253bc09e-af7e-4ef9-88c1-9e959b48e471
|
prepend_sequence
|
Prepend BBBR after Replace patterns RR with BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns BR, then put 'BRBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BRBB'",
"expected_accepted": true,
"expected_output": "BRBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BRBBR'",
"expected_accepted": true,
"expected_output": "BRBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BRBBRB'",
"expected_accepted": true,
"expected_output": "BRBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'B' → output: 'BRBBB'",
"expected_accepted": true,
"expected_output": "BRBBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'R' → output: 'BRBBR'",
"expected_accepted": true,
"expected_output": "BRBBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'BRBBRRB'",
"expected_accepted": true,
"expected_output": "BRBBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BRBBB'",
"expected_accepted": true,
"expected_output": "BRBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'B' → output: 'BRBBB'",
"expected_accepted": true,
"expected_output": "BRBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: '' → output: 'BRBB'",
"expected_accepted": true,
"expected_output": "BRBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BRBBRR'",
"expected_accepted": true,
"expected_output": "BRBBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BRBBBB'",
"expected_accepted": true,
"expected_output": "BRBBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: '' → output: 'BRBB'",
"expected_accepted": true,
"expected_output": "BRBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BRBBBBB'",
"expected_accepted": true,
"expected_output": "BRBBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BRBBRRR'",
"expected_accepted": true,
"expected_output": "BRBBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RB' → output: 'BRBBRB'",
"expected_accepted": true,
"expected_output": "BRBBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBRRRRBB' → mutated: 'BRRRBB' → output: 'BRBBBRRRBB'",
"expected_accepted": true,
"expected_output": "BRBBBRRRBB",
"input": "BBRRRRBB"
},
{
"check_output": true,
"description": "Input 'BRBBBBBBRBRR' → mutated: 'BBBBBR' → output: 'BRBBBBBBBR'",
"expected_accepted": true,
"expected_output": "BRBBBBBBBR",
"input": "BRBBBBBBRBRR"
}
] |
manufactoria
|
hard
|
d20b52c0-c38b-4f0f-ba90-f2bd651cedb0
|
prepend_sequence
|
Prepend BRBB after Remove patterns BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RB with RR, then put 'RRRR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RRRR'",
"expected_accepted": true,
"expected_output": "RRRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRRRR'",
"expected_accepted": true,
"expected_output": "RRRRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RR' → output: 'RRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RRRRBBR'",
"expected_accepted": true,
"expected_output": "RRRRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RRR' → output: 'RRRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRR' → output: 'RRRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRRRB'",
"expected_accepted": true,
"expected_output": "RRRRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRR' → output: 'RRRRBRR'",
"expected_accepted": true,
"expected_output": "RRRRBRR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RRRRBB'",
"expected_accepted": true,
"expected_output": "RRRRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BRRR' → mutated: 'BRRR' → output: 'RRRRBRRR'",
"expected_accepted": true,
"expected_output": "RRRRBRRR",
"input": "BRRR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RRRRBBB'",
"expected_accepted": true,
"expected_output": "RRRRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RRRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRRR' → output: 'RRRRBRRR'",
"expected_accepted": true,
"expected_output": "RRRRBRRR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RRRR' → output: 'RRRRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRRR",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBBBRBRR' → mutated: 'RRBBRRRR' → output: 'RRRRRRBBRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRBBRRRR",
"input": "RBBBRBRR"
},
{
"check_output": true,
"description": "Input 'RRBRRBRBBBBB' → mutated: 'RRRRRRRRBBBB' → output: 'RRRRRRRRRRRRBBBB'",
"expected_accepted": true,
"expected_output": "RRRRRRRRRRRRBBBB",
"input": "RRBRRBRBBBBB"
}
] |
manufactoria
|
hard
|
b71dffb7-68ae-4edb-9af9-860e4bd23347
|
prepend_sequence
|
Prepend RRRR after Replace patterns RB with RR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with BB, then put 'RBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBR'",
"expected_accepted": true,
"expected_output": "RBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBRR'",
"expected_accepted": true,
"expected_output": "RBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBRRB'",
"expected_accepted": true,
"expected_output": "RBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBB' → output: 'RBRRBB'",
"expected_accepted": true,
"expected_output": "RBRRBB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RBRRRB'",
"expected_accepted": true,
"expected_output": "RBRRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RBRRR'",
"expected_accepted": true,
"expected_output": "RBRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BB' → output: 'RBRBB'",
"expected_accepted": true,
"expected_output": "RBRBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BBB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBRBB'",
"expected_accepted": true,
"expected_output": "RBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBRB'",
"expected_accepted": true,
"expected_output": "RBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBBB' → output: 'RBRRBBB'",
"expected_accepted": true,
"expected_output": "RBRRBBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RBRRRR'",
"expected_accepted": true,
"expected_output": "RBRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BBBB' → output: 'RBRBBBB'",
"expected_accepted": true,
"expected_output": "RBRBBBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BRBBBBRB' → mutated: 'BBBBBBBB' → output: 'RBRBBBBBBBB'",
"expected_accepted": true,
"expected_output": "RBRBBBBBBBB",
"input": "BRBBBBRB"
},
{
"check_output": true,
"description": "Input 'RRRRRBBRRBRR' → mutated: 'RRRRRBBBRBBR' → output: 'RBRRRRRRBBBRBBR'",
"expected_accepted": true,
"expected_output": "RBRRRRRRBBBRBBR",
"input": "RRRRRBBRRBRR"
}
] |
manufactoria
|
hard
|
86e0aa06-e2cc-4328-a122-5eaa03fb73cd
|
prepend_sequence
|
Prepend RBR after Replace patterns BR with BB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with BR, then put 'BBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBBBBR'",
"expected_accepted": true,
"expected_output": "BBBBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'BRB' → output: 'BBBBRB'",
"expected_accepted": true,
"expected_output": "BBBBRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBBB'",
"expected_accepted": true,
"expected_output": "BBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'BR' → output: 'BBBBR'",
"expected_accepted": true,
"expected_output": "BBBBR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBBBR'",
"expected_accepted": true,
"expected_output": "BBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BBBBRB'",
"expected_accepted": true,
"expected_output": "BBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBBBB'",
"expected_accepted": true,
"expected_output": "BBBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BBBBRBR'",
"expected_accepted": true,
"expected_output": "BBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBBBBB'",
"expected_accepted": true,
"expected_output": "BBBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'BRR' → output: 'BBBBRR'",
"expected_accepted": true,
"expected_output": "BBBBRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BBBRBRB'",
"expected_accepted": true,
"expected_output": "BBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRRRBRR' → mutated: 'RBBRRBBR' → output: 'BBBRBBRRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBRRBBR",
"input": "RBRRRBRR"
},
{
"check_output": true,
"description": "Input 'RRBRBRBBBBBB' → mutated: 'BRBRBRBBBBBB' → output: 'BBBBRBRBRBBBBBB'",
"expected_accepted": true,
"expected_output": "BBBBRBRBRBBBBBB",
"input": "RRBRBRBBBBBB"
}
] |
manufactoria
|
hard
|
fdb519af-b487-4805-872f-e174ee509c8d
|
prepend_sequence
|
Prepend BBB after Replace patterns RR with BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with B, then put 'RR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RR'",
"expected_accepted": true,
"expected_output": "RR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRR'",
"expected_accepted": true,
"expected_output": "RRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RRBBR'",
"expected_accepted": true,
"expected_output": "RRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RRRBR'",
"expected_accepted": true,
"expected_output": "RRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'BB' → output: 'RRBB'",
"expected_accepted": true,
"expected_output": "RRBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'B' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RRBR'",
"expected_accepted": true,
"expected_output": "RRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RRBRB'",
"expected_accepted": true,
"expected_output": "RRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RRBB'",
"expected_accepted": true,
"expected_output": "RRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRRB' → mutated: 'BBB' → output: 'RRBBB'",
"expected_accepted": true,
"expected_output": "RRBBB",
"input": "BRRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RRBBB'",
"expected_accepted": true,
"expected_output": "RRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'BR' → output: 'RRBR'",
"expected_accepted": true,
"expected_output": "RRBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RRBRBR'",
"expected_accepted": true,
"expected_output": "RRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RRRBRB'",
"expected_accepted": true,
"expected_output": "RRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRBBRBB' → mutated: 'RBRBBRBB' → output: 'RRRBRBBRBB'",
"expected_accepted": true,
"expected_output": "RRRBRBBRBB",
"input": "RBRBBRBB"
},
{
"check_output": true,
"description": "Input 'RBBBRRRRBRRR' → mutated: 'RBBBBBBBR' → output: 'RRRBBBBBBBR'",
"expected_accepted": true,
"expected_output": "RRRBBBBBBBR",
"input": "RBBBRRRRBRRR"
}
] |
manufactoria
|
hard
|
dc8a5f1c-7639-4b67-be4b-d055b13dc791
|
prepend_sequence
|
Prepend RR after Replace patterns RR with B
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RB with BB, then put 'BBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBR'",
"expected_accepted": true,
"expected_output": "BBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBRR'",
"expected_accepted": true,
"expected_output": "BBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'BB' → output: 'BBRBB'",
"expected_accepted": true,
"expected_output": "BBRBB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBRBBR'",
"expected_accepted": true,
"expected_output": "BBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'BBR' → output: 'BBRBBR'",
"expected_accepted": true,
"expected_output": "BBRBBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RBB' → output: 'BBRRBB'",
"expected_accepted": true,
"expected_output": "BBRRBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BBB' → output: 'BBRBBB'",
"expected_accepted": true,
"expected_output": "BBRBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBRBR'",
"expected_accepted": true,
"expected_output": "BBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBRBB'",
"expected_accepted": true,
"expected_output": "BBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBRB'",
"expected_accepted": true,
"expected_output": "BBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BBRRR'",
"expected_accepted": true,
"expected_output": "BBRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'BBBB' → output: 'BBRBBBB'",
"expected_accepted": true,
"expected_output": "BBRBBBB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBRBBB'",
"expected_accepted": true,
"expected_output": "BBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BBRRRR'",
"expected_accepted": true,
"expected_output": "BBRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BBBR' → output: 'BBRBBBR'",
"expected_accepted": true,
"expected_output": "BBRBBBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'BBBB' → output: 'BBRBBBB'",
"expected_accepted": true,
"expected_output": "BBRBBBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRBRRRB' → mutated: 'BBBBRRBB' → output: 'BBRBBBBRRBB'",
"expected_accepted": true,
"expected_output": "BBRBBBBRRBB",
"input": "RBRBRRRB"
},
{
"check_output": true,
"description": "Input 'RRBRRBRRRBRR' → mutated: 'RBBRBBRRBBRR' → output: 'BBRRBBRBBRRBBRR'",
"expected_accepted": true,
"expected_output": "BBRRBBRBBRRBBRR",
"input": "RRBRRBRRRBRR"
}
] |
manufactoria
|
hard
|
a9ce6b5c-70e5-4ef9-b669-7a62dbeafe74
|
prepend_sequence
|
Prepend BBR after Replace patterns RB with BB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns RR, then put 'RBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBBR'",
"expected_accepted": true,
"expected_output": "RBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBBRB'",
"expected_accepted": true,
"expected_output": "RBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RBBRBR'",
"expected_accepted": true,
"expected_output": "RBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'B' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: '' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RBBBR'",
"expected_accepted": true,
"expected_output": "RBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BBRB' → mutated: 'BBRB' → output: 'RBBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBBRB",
"input": "BBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'R' → output: 'RBBR'",
"expected_accepted": true,
"expected_output": "RBBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RBBRBRB'",
"expected_accepted": true,
"expected_output": "RBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RRRBRBBB' → mutated: 'RBRBBB' → output: 'RBBRBRBBB'",
"expected_accepted": true,
"expected_output": "RBBRBRBBB",
"input": "RRRBRBBB"
},
{
"check_output": true,
"description": "Input 'BBRBRBRBRRRR' → mutated: 'BBRBRBRB' → output: 'RBBBBRBRBRB'",
"expected_accepted": true,
"expected_output": "RBBBBRBRBRB",
"input": "BBRBRBRBRRRR"
}
] |
manufactoria
|
hard
|
557df39a-1394-4e69-9da3-53c92311686e
|
prepend_sequence
|
Prepend RBB after Remove patterns RR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BB with RB, then put 'RBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBBR'",
"expected_accepted": true,
"expected_output": "RBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBBRB'",
"expected_accepted": true,
"expected_output": "RBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'RBR' → output: 'RBBRBR'",
"expected_accepted": true,
"expected_output": "RBBRBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RBBRBR'",
"expected_accepted": true,
"expected_output": "RBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RBBRRB'",
"expected_accepted": true,
"expected_output": "RBBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RBBRR'",
"expected_accepted": true,
"expected_output": "RBBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RBBBR'",
"expected_accepted": true,
"expected_output": "RBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'RB' → output: 'RBBRB'",
"expected_accepted": true,
"expected_output": "RBBRB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RRRB' → mutated: 'RRRB' → output: 'RBBRRRB'",
"expected_accepted": true,
"expected_output": "RBBRRRB",
"input": "RRRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'RBB' → output: 'RBBRBB'",
"expected_accepted": true,
"expected_output": "RBBRBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RBBRRR'",
"expected_accepted": true,
"expected_output": "RBBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RBBRBRB'",
"expected_accepted": true,
"expected_output": "RBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRBRBBB' → mutated: 'RBRBRRBB' → output: 'RBBRBRBRRBB'",
"expected_accepted": true,
"expected_output": "RBBRBRBRRBB",
"input": "RBRBRBBB"
},
{
"check_output": true,
"description": "Input 'BRRRBBRRBRBB' → mutated: 'BRRRRBRRBRRB' → output: 'RBBBRRRRBRRBRRB'",
"expected_accepted": true,
"expected_output": "RBBBRRRRBRRBRRB",
"input": "BRRRBBRRBRBB"
}
] |
manufactoria
|
hard
|
995e5fe2-f8f0-4dfe-a814-00399eae71c6
|
prepend_sequence
|
Prepend RBB after Replace patterns BB with RB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BB with BR, then put 'BRR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BRR'",
"expected_accepted": true,
"expected_output": "BRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BRRR'",
"expected_accepted": true,
"expected_output": "BRRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BRRRB'",
"expected_accepted": true,
"expected_output": "BRRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BRR' → output: 'BRRBRR'",
"expected_accepted": true,
"expected_output": "BRRBRR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BRRRBR'",
"expected_accepted": true,
"expected_output": "BRRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'BRRRRB'",
"expected_accepted": true,
"expected_output": "BRRRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BRRB'",
"expected_accepted": true,
"expected_output": "BRRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BRRBRB'",
"expected_accepted": true,
"expected_output": "BRRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BRRBR'",
"expected_accepted": true,
"expected_output": "BRRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BRRRR'",
"expected_accepted": true,
"expected_output": "BRRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BR' → output: 'BRRBR'",
"expected_accepted": true,
"expected_output": "BRRBR",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'RBRB' → output: 'BRRRBRB'",
"expected_accepted": true,
"expected_output": "BRRRBRB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BRB' → output: 'BRRBRB'",
"expected_accepted": true,
"expected_output": "BRRBRB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BRRRRR'",
"expected_accepted": true,
"expected_output": "BRRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BRRBRBR'",
"expected_accepted": true,
"expected_output": "BRRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BRRRBRB'",
"expected_accepted": true,
"expected_output": "BRRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBRBRRRR' → mutated: 'BRRBRRRR' → output: 'BRRBRRBRRRR'",
"expected_accepted": true,
"expected_output": "BRRBRRBRRRR",
"input": "BBRBRRRR"
},
{
"check_output": true,
"description": "Input 'BRRBRBRBBRRB' → mutated: 'BRRBRBRBRRRB' → output: 'BRRBRRBRBRBRRRB'",
"expected_accepted": true,
"expected_output": "BRRBRRBRBRBRRRB",
"input": "BRRBRBRBBRRB"
}
] |
manufactoria
|
hard
|
8ebae0f9-fa16-496f-8ee4-4604c4130907
|
prepend_sequence
|
Prepend BRR after Replace patterns BB with BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with BB, then put 'R' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'R'",
"expected_accepted": true,
"expected_output": "R",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RR'",
"expected_accepted": true,
"expected_output": "RR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBB' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBB' → output: 'RRBB'",
"expected_accepted": true,
"expected_output": "RRBB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RRR'",
"expected_accepted": true,
"expected_output": "RRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BB' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BBB' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RB'",
"expected_accepted": true,
"expected_output": "RB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'RBBB' → output: 'RRBBB'",
"expected_accepted": true,
"expected_output": "RRBBB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RRRR'",
"expected_accepted": true,
"expected_output": "RRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BBBB' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBBB' → output: 'RRBBB'",
"expected_accepted": true,
"expected_output": "RRBBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRRRRRR' → mutated: 'RBBRRRRR' → output: 'RRBBRRRRR'",
"expected_accepted": true,
"expected_output": "RRBBRRRRR",
"input": "RBRRRRRR"
},
{
"check_output": true,
"description": "Input 'BRRBBRBBRRRR' → mutated: 'BBRBBBBBBRRR' → output: 'RBBRBBBBBBRRR'",
"expected_accepted": true,
"expected_output": "RBBRBBBBBBRRR",
"input": "BRRBBRBBRRRR"
}
] |
manufactoria
|
hard
|
4f67bc8e-3622-4341-b333-5431fa97af6e
|
prepend_sequence
|
Prepend R after Replace patterns BR with BB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns BR, then put 'BRBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BRBRR'",
"expected_accepted": true,
"expected_output": "BRBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BRBRRB'",
"expected_accepted": true,
"expected_output": "BRBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'B' → output: 'BRBRB'",
"expected_accepted": true,
"expected_output": "BRBRB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'R' → output: 'BRBRR'",
"expected_accepted": true,
"expected_output": "BRBRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'BRBRRRB'",
"expected_accepted": true,
"expected_output": "BRBRRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BRBRB'",
"expected_accepted": true,
"expected_output": "BRBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BRBRRR'",
"expected_accepted": true,
"expected_output": "BRBRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: '' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'B' → output: 'BRBRB'",
"expected_accepted": true,
"expected_output": "BRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BRBRBB'",
"expected_accepted": true,
"expected_output": "BRBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BBBB' → mutated: 'BBBB' → output: 'BRBRBBBB'",
"expected_accepted": true,
"expected_output": "BRBRBBBB",
"input": "BBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BRBRBBB'",
"expected_accepted": true,
"expected_output": "BRBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BRBRRRR'",
"expected_accepted": true,
"expected_output": "BRBRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: '' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RB' → output: 'BRBRRB'",
"expected_accepted": true,
"expected_output": "BRBRRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBBBRRRB' → mutated: 'BBBRRB' → output: 'BRBRBBBRRB'",
"expected_accepted": true,
"expected_output": "BRBRBBBRRB",
"input": "BBBBRRRB"
},
{
"check_output": true,
"description": "Input 'BBRBBBRRRBBB' → mutated: 'BBBRRBBB' → output: 'BRBRBBBRRBBB'",
"expected_accepted": true,
"expected_output": "BRBRBBBRRBBB",
"input": "BBRBBBRRRBBB"
}
] |
manufactoria
|
hard
|
f804d699-bdb0-42b4-8d98-d443064fccb0
|
prepend_sequence
|
Prepend BRBR after Remove patterns BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with RB, then put 'RBRB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBRB'",
"expected_accepted": true,
"expected_output": "RBRB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBRBR'",
"expected_accepted": true,
"expected_output": "RBRBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BRB' → output: 'RBRBBRB'",
"expected_accepted": true,
"expected_output": "RBRBBRB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RRB' → output: 'RBRBRRB'",
"expected_accepted": true,
"expected_output": "RBRBRRB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RBRBRRB'",
"expected_accepted": true,
"expected_output": "RBRBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBRBB'",
"expected_accepted": true,
"expected_output": "RBRBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RBRBRR'",
"expected_accepted": true,
"expected_output": "RBRBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'RB' → output: 'RBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'RBB' → output: 'RBRBRBB'",
"expected_accepted": true,
"expected_output": "RBRBRBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RRRR' → mutated: 'RRRR' → output: 'RBRBRRRR'",
"expected_accepted": true,
"expected_output": "RBRBRRRR",
"input": "RRRR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBRBBBB'",
"expected_accepted": true,
"expected_output": "RBRBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RBRBRRR'",
"expected_accepted": true,
"expected_output": "RBRBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'RBRB' → output: 'RBRBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRBRB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RRBB' → output: 'RBRBRRBB'",
"expected_accepted": true,
"expected_output": "RBRBRRBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBBBRRRR' → mutated: 'BBBRBRRR' → output: 'RBRBBBBRBRRR'",
"expected_accepted": true,
"expected_output": "RBRBBBBRBRRR",
"input": "BBBBRRRR"
},
{
"check_output": true,
"description": "Input 'RRBBBBBRBRBB' → mutated: 'RRBBBBRBRBBB' → output: 'RBRBRRBBBBRBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBRRBBBBRBRBBB",
"input": "RRBBBBBRBRBB"
}
] |
manufactoria
|
hard
|
6f4147ed-ce1d-495a-b708-b1e8a1789bc2
|
prepend_sequence
|
Prepend RBRB after Replace patterns BR with RB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with R, then put 'BRBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BRBRR'",
"expected_accepted": true,
"expected_output": "BRBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BRBRRB'",
"expected_accepted": true,
"expected_output": "BRBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BRBRBBR'",
"expected_accepted": true,
"expected_output": "BRBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BRBRRBR'",
"expected_accepted": true,
"expected_output": "BRBRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RB' → output: 'BRBRRB'",
"expected_accepted": true,
"expected_output": "BRBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'R' → output: 'BRBRR'",
"expected_accepted": true,
"expected_output": "BRBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BRBRBR'",
"expected_accepted": true,
"expected_output": "BRBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BRBRBRB'",
"expected_accepted": true,
"expected_output": "BRBRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BRBRB'",
"expected_accepted": true,
"expected_output": "BRBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BRBRBB'",
"expected_accepted": true,
"expected_output": "BRBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BRBRRBRB'",
"expected_accepted": true,
"expected_output": "BRBRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BRBRBBB'",
"expected_accepted": true,
"expected_output": "BRBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RR' → output: 'BRBRRR'",
"expected_accepted": true,
"expected_output": "BRBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BRBRBRBR'",
"expected_accepted": true,
"expected_output": "BRBRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BRRBRBBB' → mutated: 'BRBRBBB' → output: 'BRBRBRBRBBB'",
"expected_accepted": true,
"expected_output": "BRBRBRBRBBB",
"input": "BRRBRBBB"
},
{
"check_output": true,
"description": "Input 'BRBBRRBRBRRB' → mutated: 'BRBBRBRBRB' → output: 'BRBRBRBBRBRBRB'",
"expected_accepted": true,
"expected_output": "BRBRBRBBRBRBRB",
"input": "BRBBRRBRBRRB"
}
] |
manufactoria
|
hard
|
6255f7c5-030d-435e-92df-696a478fb55d
|
prepend_sequence
|
Prepend BRBR after Replace patterns RR with R
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BB with RB, then put 'RBRB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBRB'",
"expected_accepted": true,
"expected_output": "RBRB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBRBR'",
"expected_accepted": true,
"expected_output": "RBRBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'RBR' → output: 'RBRBRBR'",
"expected_accepted": true,
"expected_output": "RBRBRBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RBRBRBR'",
"expected_accepted": true,
"expected_output": "RBRBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RBRBRRB'",
"expected_accepted": true,
"expected_output": "RBRBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RBRBBRB'",
"expected_accepted": true,
"expected_output": "RBRBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RBRBBR'",
"expected_accepted": true,
"expected_output": "RBRBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBRBB'",
"expected_accepted": true,
"expected_output": "RBRBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RBRBRR'",
"expected_accepted": true,
"expected_output": "RBRBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'RB' → output: 'RBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BRBB' → mutated: 'BRRB' → output: 'RBRBBRRB'",
"expected_accepted": true,
"expected_output": "RBRBBRRB",
"input": "BRBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'RBB' → output: 'RBRBRBB'",
"expected_accepted": true,
"expected_output": "RBRBRBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RBRBRRR'",
"expected_accepted": true,
"expected_output": "RBRBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RBRBBRBR'",
"expected_accepted": true,
"expected_output": "RBRBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RBRBRBRB'",
"expected_accepted": true,
"expected_output": "RBRBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBBRBRBR' → mutated: 'RRBRBRBR' → output: 'RBRBRRBRBRBR'",
"expected_accepted": true,
"expected_output": "RBRBRRBRBRBR",
"input": "RBBRBRBR"
},
{
"check_output": true,
"description": "Input 'BBBBBBBRRBBR' → mutated: 'RBRBRBBRRRBR' → output: 'RBRBRBRBRBBRRRBR'",
"expected_accepted": true,
"expected_output": "RBRBRBRBRBBRRRBR",
"input": "BBBBBBBRRBBR"
}
] |
manufactoria
|
hard
|
b3c4d577-a760-4fca-b637-a1dc64c18a58
|
prepend_sequence
|
Prepend RBRB after Replace patterns BB with RB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns RR, then put 'RBBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBBBR'",
"expected_accepted": true,
"expected_output": "RBBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RBBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'B' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: '' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RBBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BRBB' → mutated: 'BRBB' → output: 'RBBBBRBB'",
"expected_accepted": true,
"expected_output": "RBBBBRBB",
"input": "BRBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'R' → output: 'RBBBR'",
"expected_accepted": true,
"expected_output": "RBBBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RBBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RBBBRBRB'",
"expected_accepted": true,
"expected_output": "RBBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBBBRBBR' → mutated: 'RBBBRBBR' → output: 'RBBBRBBBRBBR'",
"expected_accepted": true,
"expected_output": "RBBBRBBBRBBR",
"input": "RBBBRBBR"
},
{
"check_output": true,
"description": "Input 'BBRRBBBRRRBB' → mutated: 'BBBBBRBB' → output: 'RBBBBBBBBRBB'",
"expected_accepted": true,
"expected_output": "RBBBBBBBBRBB",
"input": "BBRRBBBRRRBB"
}
] |
manufactoria
|
hard
|
6b66c8d8-2120-429d-a90f-2ce9add47f24
|
prepend_sequence
|
Prepend RBBB after Remove patterns RR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with B, then put 'B' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'B'",
"expected_accepted": true,
"expected_output": "B",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BR'",
"expected_accepted": true,
"expected_output": "BR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BRB'",
"expected_accepted": true,
"expected_output": "BRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BB' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RB' → output: 'BRB'",
"expected_accepted": true,
"expected_output": "BRB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'BRRB'",
"expected_accepted": true,
"expected_output": "BRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BB'",
"expected_accepted": true,
"expected_output": "BB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BB' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'B' → output: 'BB'",
"expected_accepted": true,
"expected_output": "BB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BRR'",
"expected_accepted": true,
"expected_output": "BRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BBRB' → mutated: 'BBB' → output: 'BBBB'",
"expected_accepted": true,
"expected_output": "BBBB",
"input": "BBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBBB'",
"expected_accepted": true,
"expected_output": "BBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BRRR'",
"expected_accepted": true,
"expected_output": "BRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BB' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBB' → output: 'BRBB'",
"expected_accepted": true,
"expected_output": "BRBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBRBBRBR' → mutated: 'BBBBB' → output: 'BBBBBB'",
"expected_accepted": true,
"expected_output": "BBBBBB",
"input": "BBRBBRBR"
},
{
"check_output": true,
"description": "Input 'RBBBRBRRBRBB' → mutated: 'RBBBBRBBB' → output: 'BRBBBBRBBB'",
"expected_accepted": true,
"expected_output": "BRBBBBRBBB",
"input": "RBBBRBRRBRBB"
}
] |
manufactoria
|
hard
|
398d0698-c38d-4f31-8780-92e5d510fd33
|
prepend_sequence
|
Prepend B after Replace patterns BR with B
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BB with B, then put 'BBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBB'",
"expected_accepted": true,
"expected_output": "BBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BR' → output: 'BBBBR'",
"expected_accepted": true,
"expected_output": "BBBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'BBBRRB'",
"expected_accepted": true,
"expected_output": "BBBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBBB'",
"expected_accepted": true,
"expected_output": "BBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBBBR'",
"expected_accepted": true,
"expected_output": "BBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BBBBRB'",
"expected_accepted": true,
"expected_output": "BBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'B' → output: 'BBBB'",
"expected_accepted": true,
"expected_output": "BBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RRRB' → mutated: 'RRRB' → output: 'BBBRRRB'",
"expected_accepted": true,
"expected_output": "BBBRRRB",
"input": "RRRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BB' → output: 'BBBBB'",
"expected_accepted": true,
"expected_output": "BBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BBBRRR'",
"expected_accepted": true,
"expected_output": "BBBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BBBBRBR'",
"expected_accepted": true,
"expected_output": "BBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BBBRBRB'",
"expected_accepted": true,
"expected_output": "BBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBRRBBRR' → mutated: 'BRRBRR' → output: 'BBBBRRBRR'",
"expected_accepted": true,
"expected_output": "BBBBRRBRR",
"input": "BBRRBBRR"
},
{
"check_output": true,
"description": "Input 'BRRBRRBBBBRB' → mutated: 'BRRBRRBBRB' → output: 'BBBBRRBRRBBRB'",
"expected_accepted": true,
"expected_output": "BBBBRRBRRBBRB",
"input": "BRRBRRBBBBRB"
}
] |
manufactoria
|
hard
|
4d512e3c-1c6e-45bf-8ffe-7236503b83fa
|
prepend_sequence
|
Prepend BBB after Replace patterns BB with B
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns BR, then put 'RR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RR'",
"expected_accepted": true,
"expected_output": "RR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRR'",
"expected_accepted": true,
"expected_output": "RRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'B' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'R' → output: 'RRR'",
"expected_accepted": true,
"expected_output": "RRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RRRRB'",
"expected_accepted": true,
"expected_output": "RRRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'B' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: '' → output: 'RR'",
"expected_accepted": true,
"expected_output": "RR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RRBB'",
"expected_accepted": true,
"expected_output": "RRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRB'",
"expected_accepted": true,
"expected_output": "RRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RRRR'",
"expected_accepted": true,
"expected_output": "RRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: '' → output: 'RR'",
"expected_accepted": true,
"expected_output": "RR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RRBBB'",
"expected_accepted": true,
"expected_output": "RRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RRRRR'",
"expected_accepted": true,
"expected_output": "RRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RB' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBBBBBBB' → mutated: 'BBBBBBBB' → output: 'RRBBBBBBBB'",
"expected_accepted": true,
"expected_output": "RRBBBBBBBB",
"input": "BBBBBBBB"
},
{
"check_output": true,
"description": "Input 'RRRRRBRBBBBR' → mutated: 'RRRRRBBB' → output: 'RRRRRRRBBB'",
"expected_accepted": true,
"expected_output": "RRRRRRRBBB",
"input": "RRRRRBRBBBBR"
}
] |
manufactoria
|
hard
|
d91e8acc-e7e7-4dce-a5aa-e7ec8d4609b4
|
prepend_sequence
|
Prepend RR after Remove patterns BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BB with BR, then put 'RRRR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RRRR'",
"expected_accepted": true,
"expected_output": "RRRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRRRR'",
"expected_accepted": true,
"expected_output": "RRRRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRRRRB'",
"expected_accepted": true,
"expected_output": "RRRRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BRR' → output: 'RRRRBRR'",
"expected_accepted": true,
"expected_output": "RRRRBRR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RRRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RRRRRRB'",
"expected_accepted": true,
"expected_output": "RRRRRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RRRRBRB'",
"expected_accepted": true,
"expected_output": "RRRRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BR' → output: 'RRRRBR'",
"expected_accepted": true,
"expected_output": "RRRRBR",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRRRB'",
"expected_accepted": true,
"expected_output": "RRRRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RRRRBRBR'",
"expected_accepted": true,
"expected_output": "RRRRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BRB' → output: 'RRRRBRB'",
"expected_accepted": true,
"expected_output": "RRRRBRB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RRRRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RRRRRBRB'",
"expected_accepted": true,
"expected_output": "RRRRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRBBRRR' → mutated: 'RBRBRRRR' → output: 'RRRRRBRBRRRR'",
"expected_accepted": true,
"expected_output": "RRRRRBRBRRRR",
"input": "RBRBBRRR"
},
{
"check_output": true,
"description": "Input 'BBBBBRRBRRRB' → mutated: 'BRBRBRRBRRRB' → output: 'RRRRBRBRBRRBRRRB'",
"expected_accepted": true,
"expected_output": "RRRRBRBRBRRBRRRB",
"input": "BBBBBRRBRRRB"
}
] |
manufactoria
|
hard
|
3c672174-e6d6-4a10-901a-8dd42bfe1fdb
|
prepend_sequence
|
Prepend RRRR after Replace patterns BB with BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with BB, then put 'RB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RB'",
"expected_accepted": true,
"expected_output": "RB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBR'",
"expected_accepted": true,
"expected_output": "RBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBRB'",
"expected_accepted": true,
"expected_output": "RBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBB' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBB' → output: 'RBRBB'",
"expected_accepted": true,
"expected_output": "RBRBB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RBRRB'",
"expected_accepted": true,
"expected_output": "RBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RBRR'",
"expected_accepted": true,
"expected_output": "RBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BB' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BBB' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBB'",
"expected_accepted": true,
"expected_output": "RBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'RBBB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RBRRR'",
"expected_accepted": true,
"expected_output": "RBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BBBB' → output: 'RBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBBB' → output: 'RBRBBB'",
"expected_accepted": true,
"expected_output": "RBRBBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RRRBRBBR' → mutated: 'RRRBBBBB' → output: 'RBRRRBBBBB'",
"expected_accepted": true,
"expected_output": "RBRRRBBBBB",
"input": "RRRBRBBR"
},
{
"check_output": true,
"description": "Input 'RRRBBBRBBRBB' → mutated: 'RRRBBBBBBBBB' → output: 'RBRRRBBBBBBBBB'",
"expected_accepted": true,
"expected_output": "RBRRRBBBBBBBBB",
"input": "RRRBBBRBBRBB"
}
] |
manufactoria
|
hard
|
ae95af75-0ee9-4cfb-9e52-7863d2fecb4d
|
prepend_sequence
|
Prepend RB after Replace patterns BR with BB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RB with BR, then put 'BR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BR'",
"expected_accepted": true,
"expected_output": "BR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BRR'",
"expected_accepted": true,
"expected_output": "BRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'BR' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BRBBR'",
"expected_accepted": true,
"expected_output": "BRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'BRR' → output: 'BRBRR'",
"expected_accepted": true,
"expected_output": "BRBRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RBR' → output: 'BRRBR'",
"expected_accepted": true,
"expected_output": "BRRBR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BRB'",
"expected_accepted": true,
"expected_output": "BRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BBR' → output: 'BRBBR'",
"expected_accepted": true,
"expected_output": "BRBBR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BRBR'",
"expected_accepted": true,
"expected_output": "BRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BRRR'",
"expected_accepted": true,
"expected_output": "BRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BRBB'",
"expected_accepted": true,
"expected_output": "BRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BBRB' → mutated: 'BBBR' → output: 'BRBBBR'",
"expected_accepted": true,
"expected_output": "BRBBBR",
"input": "BBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BRBBB'",
"expected_accepted": true,
"expected_output": "BRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BRRRR'",
"expected_accepted": true,
"expected_output": "BRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BBRR' → output: 'BRBBRR'",
"expected_accepted": true,
"expected_output": "BRBBRR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'BRBR' → output: 'BRBRBR'",
"expected_accepted": true,
"expected_output": "BRBRBR",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RBRRBBRR' → mutated: 'BRRBRBRR' → output: 'BRBRRBRBRR'",
"expected_accepted": true,
"expected_output": "BRBRRBRBRR",
"input": "RBRRBBRR"
},
{
"check_output": true,
"description": "Input 'RBRRBRBBBRBR' → mutated: 'BRRBRBRBBBRR' → output: 'BRBRRBRBRBBBRR'",
"expected_accepted": true,
"expected_output": "BRBRRBRBRBBBRR",
"input": "RBRRBRBBBRBR"
}
] |
manufactoria
|
hard
|
6141049d-5864-4cc2-9eab-7018fe4c3df3
|
prepend_sequence
|
Prepend BR after Replace patterns RB with BR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns BR with B, then put 'RRRB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RRRB'",
"expected_accepted": true,
"expected_output": "RRRB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RRRBR'",
"expected_accepted": true,
"expected_output": "RRRBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RRRBRB'",
"expected_accepted": true,
"expected_output": "RRRBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BB' → output: 'RRRBBB'",
"expected_accepted": true,
"expected_output": "RRRBBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RB' → output: 'RRRBRB'",
"expected_accepted": true,
"expected_output": "RRRBRB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'RRB' → output: 'RRRBRRB'",
"expected_accepted": true,
"expected_output": "RRRBRRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RRRBB'",
"expected_accepted": true,
"expected_output": "RRRBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BB' → output: 'RRRBBB'",
"expected_accepted": true,
"expected_output": "RRRBBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'B' → output: 'RRRBB'",
"expected_accepted": true,
"expected_output": "RRRBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'RRRBRR'",
"expected_accepted": true,
"expected_output": "RRRBRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RRRBBB'",
"expected_accepted": true,
"expected_output": "RRRBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'RBBB' → output: 'RRRBRBBB'",
"expected_accepted": true,
"expected_output": "RRRBRBBB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RRRBBBB'",
"expected_accepted": true,
"expected_output": "RRRBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'RRRBRRR'",
"expected_accepted": true,
"expected_output": "RRRBRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BB' → output: 'RRRBBB'",
"expected_accepted": true,
"expected_output": "RRRBBB",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBB' → output: 'RRRBRBB'",
"expected_accepted": true,
"expected_output": "RRRBRBB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RRRBRRRR' → mutated: 'RRRBRRR' → output: 'RRRBRRRBRRR'",
"expected_accepted": true,
"expected_output": "RRRBRRRBRRR",
"input": "RRRBRRRR"
},
{
"check_output": true,
"description": "Input 'BRRBBBBRRRBB' → mutated: 'BRBBBBRRBB' → output: 'RRRBBRBBBBRRBB'",
"expected_accepted": true,
"expected_output": "RRRBBRBBBBRRBB",
"input": "BRRBBBBRRRBB"
}
] |
manufactoria
|
hard
|
04af2f97-c770-4c57-be4d-9efb41a47c43
|
prepend_sequence
|
Prepend RRRB after Replace patterns BR with B
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns RB, then put 'BBBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: '' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBBRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'R' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'R' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'RR' → output: 'BBBRRR'",
"expected_accepted": true,
"expected_output": "BBBRRR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'B' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBBRBB'",
"expected_accepted": true,
"expected_output": "BBBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: '' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBBRBBB'",
"expected_accepted": true,
"expected_output": "BBBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'RRR' → output: 'BBBRRRR'",
"expected_accepted": true,
"expected_output": "BBBRRRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'BRRRRRBB' → mutated: 'BRRRRB' → output: 'BBBRBRRRRB'",
"expected_accepted": true,
"expected_output": "BBBRBRRRRB",
"input": "BRRRRRBB"
},
{
"check_output": true,
"description": "Input 'BRRBBBRBBBRB' → mutated: 'BRBBBB' → output: 'BBBRBRBBBB'",
"expected_accepted": true,
"expected_output": "BBBRBRBBBB",
"input": "BRRBBBRBBBRB"
}
] |
manufactoria
|
hard
|
c75a111f-e9ff-4f5f-b096-87f6418c6f61
|
prepend_sequence
|
Prepend BBBR after Remove patterns RB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with BB, then put 'BBBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBBR'",
"expected_accepted": true,
"expected_output": "BBBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBBRR'",
"expected_accepted": true,
"expected_output": "BBBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BBBRRB'",
"expected_accepted": true,
"expected_output": "BBBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBBRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BBBRRBR'",
"expected_accepted": true,
"expected_output": "BBBRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'BBB' → output: 'BBBRBBB'",
"expected_accepted": true,
"expected_output": "BBBRBBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'BB' → output: 'BBBRBB'",
"expected_accepted": true,
"expected_output": "BBBRBB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BBBRBRB'",
"expected_accepted": true,
"expected_output": "BBBRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBBRB'",
"expected_accepted": true,
"expected_output": "BBBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBBRBB'",
"expected_accepted": true,
"expected_output": "BBBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BBRB' → mutated: 'BBRB' → output: 'BBBRBBRB'",
"expected_accepted": true,
"expected_output": "BBBRBBRB",
"input": "BBRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBBRBBB'",
"expected_accepted": true,
"expected_output": "BBBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'BBR' → output: 'BBBRBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BBBRBRBR'",
"expected_accepted": true,
"expected_output": "BBBRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BBBRRBRB'",
"expected_accepted": true,
"expected_output": "BBBRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBBRBRRR' → mutated: 'BBBRBBBR' → output: 'BBBRBBBRBBBR'",
"expected_accepted": true,
"expected_output": "BBBRBBBRBBBR",
"input": "BBBRBRRR"
},
{
"check_output": true,
"description": "Input 'BRRRRBRBRRBB' → mutated: 'BBBBBBRBBBBB' → output: 'BBBRBBBBBBRBBBBB'",
"expected_accepted": true,
"expected_output": "BBBRBBBBBBRBBBBB",
"input": "BRRRRBRBRRBB"
}
] |
manufactoria
|
hard
|
de0ad2e7-9ecd-428f-a5d7-b803aa04ab15
|
prepend_sequence
|
Prepend BBBR after Replace patterns RR with BB
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nRemove patterns RR, then put 'BBR' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'BBR'",
"expected_accepted": true,
"expected_output": "BBR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'BBRR'",
"expected_accepted": true,
"expected_output": "BBRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'BBRRB'",
"expected_accepted": true,
"expected_output": "BBRRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'BBRBBR'",
"expected_accepted": true,
"expected_output": "BBRBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'BBRRBR'",
"expected_accepted": true,
"expected_output": "BBRRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'B' → output: 'BBRB'",
"expected_accepted": true,
"expected_output": "BBRB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'BBRB'",
"expected_accepted": true,
"expected_output": "BBRB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'BBRBRB'",
"expected_accepted": true,
"expected_output": "BBRBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'BBRBR'",
"expected_accepted": true,
"expected_output": "BBRBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'BBRBB'",
"expected_accepted": true,
"expected_output": "BBRBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: '' → output: 'BBR'",
"expected_accepted": true,
"expected_output": "BBR",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'RBBB' → mutated: 'RBBB' → output: 'BBRRBBB'",
"expected_accepted": true,
"expected_output": "BBRRBBB",
"input": "RBBB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'BBRBBB'",
"expected_accepted": true,
"expected_output": "BBRBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'R' → output: 'BBRR'",
"expected_accepted": true,
"expected_output": "BBRR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'BBRBRBR'",
"expected_accepted": true,
"expected_output": "BBRBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'BBRRBRB'",
"expected_accepted": true,
"expected_output": "BBRRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'RRBRBRRB' → mutated: 'BRBB' → output: 'BBRBRBB'",
"expected_accepted": true,
"expected_output": "BBRBRBB",
"input": "RRBRBRRB"
},
{
"check_output": true,
"description": "Input 'BRRBRBRBBRRR' → mutated: 'BBRBRBBR' → output: 'BBRBBRBRBBR'",
"expected_accepted": true,
"expected_output": "BBRBBRBRBBR",
"input": "BRRBRBRBBRRR"
}
] |
manufactoria
|
hard
|
d8452551-6d5b-4d43-bfb9-67cd90f16dde
|
prepend_sequence
|
Prepend BBR after Remove patterns RR
|
[
{
"content": "# Manufactoria Solution DSL\n\nA Domain Specific Language for describing Manufactoria puzzle solutions in text format.\n\n## Overview\n\nManufactoria is a puzzle game where you build automated factories to sort robots based on their colored tape patterns. Robots enter your factory carrying sequences of colored tape, and you must route them to the correct destinations based on the given criteria.\n\n## Game Mechanics\n\n### Robots and Tape\n- **Robots**: Each robot carries a sequence of colored tapes\n- **Tape Colors**: Primary colors are Blue (B) and Red (R), with additional Yellow (Y) and Green (G) for advanced puzzles\n- **Tape Representation**: Sequences are represented as strings (e.g., `RBRR`, `BBR`, or empty string `\"\"`)\n\n### Operations\n- **Pull**: Remove tape from the front of the robot's sequence\n- **Paint**: Add colored tape to the end of the robot's sequence\n- **Route**: Direct robots through the factory based on their current tape state\n\n### Objective (output check)\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node and meets the puzzle's acceptance criteria\n- **Rejected**: Robot is routed to the NONE node, or caught in an infinite loop, or robot reaches the END node but fails to meet the puzzle's acceptance criteria \n\n## DSL Syntax\n\n### Program Structure\n\nEvery solution must start with a `START` directive and end with an `END` directive, wrapped in ```manufactoria ...```:\n\n```manufactoria\nSTART start:\n NEXT <next_node_id>\n\n# Factory logic goes here\n\nEND end\n```\n\n### Node Types\n\n#### 1. Puller Nodes\n\nPullers remove specific colors from the front of the robot's tape sequence and route based on the current front color.\n\n**Red/Blue Puller:**\n\n```manufactoria\nPULLER_RB <node_id>:\n [R] <next_node_id> # Route and remove color if front tape is Red\n [B] <next_node_id> # Route and remove color if front tape is Blue\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither red nor blue\n```\n\n**Yellow/Green Puller:**\n\n```manufactoria\nPULLER_YG <node_id>:\n [Y] <next_node_id> # Route and remove color if front tape is Yellow\n [G] <next_node_id> # Route and remove color if front tape is Green\n [EMPTY] <next_node_id> # Route if no tape or front tape is neither yellow nor green\n```\n\n**Note**: Unspecified branches default to `NONE`, which rejects the robot.\n\n#### 2. Painter Nodes\n\nPainters add colored tape to the end of the robot's sequence and continue to the next node.\n\n```manufactoria\nPAINTER_RED <node_id>:\n NEXT <next_node_id>\n\nPAINTER_BLUE <node_id>:\n NEXT <next_node_id>\n\nPAINTER_YELLOW <node_id>:\n NEXT <next_node_id>\n\nPAINTER_GREEN <node_id>:\n NEXT <next_node_id>\n```\n\n## Syntax Rules\n\n1. **Node IDs**: Must be unique identifiers (alphanumeric characters and underscores only)\n2. **Comments**: Lines starting with `#` are comments (single-line only)\n3. **Indentation**: Use consistent spaces or tabs for route definitions\n4. **Case Sensitivity**: Colors must be uppercase (R, B, Y, G)\n5. **Termination**: \n - Robots routed to `NONE` are rejected\n - Robots routed to the END node are accepted if they meet the puzzle criteria, otherwise rejected\n6. **Code Blocks**: Final factory code should be wrapped in triple backticks with ``` markers\n\n## Example\n\nHere's a simple example that accepts robots with exactly one red tape (ending tape should be empty):\n\n```manufactoria\nSTART start:\n NEXT entry\n\nPULLER_RB entry:\n [R] end\n\nEND end\n```\n\n# Task \nYour task is to design a factory with code with following functionality:\n\nReplace patterns RR with BB, then put 'RBBB' at the beginning of the tape. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' → mutated: '' → output: 'RBBB'",
"expected_accepted": true,
"expected_output": "RBBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' → mutated: 'R' → output: 'RBBBR'",
"expected_accepted": true,
"expected_output": "RBBBR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' → mutated: 'RB' → output: 'RBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBRB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' → mutated: 'BBR' → output: 'RBBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBBR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' → mutated: 'RBR' → output: 'RBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBRBR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' → mutated: 'BBB' → output: 'RBBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' → mutated: 'BRB' → output: 'RBBBBRB'",
"expected_accepted": true,
"expected_output": "RBBBBRB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' → mutated: 'BR' → output: 'RBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' → mutated: 'BB' → output: 'RBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBB",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'B' → mutated: 'B' → output: 'RBBBB'",
"expected_accepted": true,
"expected_output": "RBBBB",
"input": "B"
},
{
"check_output": true,
"description": "Input 'RR' → mutated: 'BB' → output: 'RBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBB",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BRRB' → mutated: 'BBBB' → output: 'RBBBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBBBB",
"input": "BRRB"
},
{
"check_output": true,
"description": "Input 'BBB' → mutated: 'BBB' → output: 'RBBBBBB'",
"expected_accepted": true,
"expected_output": "RBBBBBB",
"input": "BBB"
},
{
"check_output": true,
"description": "Input 'RRR' → mutated: 'BBR' → output: 'RBBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBBR",
"input": "RRR"
},
{
"check_output": true,
"description": "Input 'BRBR' → mutated: 'BRBR' → output: 'RBBBBRBR'",
"expected_accepted": true,
"expected_output": "RBBBBRBR",
"input": "BRBR"
},
{
"check_output": true,
"description": "Input 'RBRB' → mutated: 'RBRB' → output: 'RBBBRBRB'",
"expected_accepted": true,
"expected_output": "RBBBRBRB",
"input": "RBRB"
},
{
"check_output": true,
"description": "Input 'BBRBRRBR' → mutated: 'BBRBBBBR' → output: 'RBBBBBRBBBBR'",
"expected_accepted": true,
"expected_output": "RBBBBBRBBBBR",
"input": "BBRBRRBR"
},
{
"check_output": true,
"description": "Input 'RBRRRRRRRBRB' → mutated: 'RBBBBBBBRBRB' → output: 'RBBBRBBBBBBBRBRB'",
"expected_accepted": true,
"expected_output": "RBBBRBBBBBBBRBRB",
"input": "RBRRRRRRRBRB"
}
] |
manufactoria
|
hard
|
5e309773-99e5-4072-ab52-74034a94c815
|
prepend_sequence
|
Prepend RBBB after Replace patterns RR with BB
|
End of preview. Expand
in Data Studio
- Downloads last month
- 11