messages
listlengths 1
1
| ground_truth
listlengths 14
20
| dataset
stringclasses 1
value | difficulty
stringclasses 1
value | id
stringlengths 36
36
| problem_family
stringclasses 3
values | name
stringlengths 11
18
|
|---|---|---|---|---|---|---|
[
{
"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\nAccept any input and append the sequence 'BGYR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'BGYR'",
"expected_accepted": true,
"expected_output": "BGYR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RBGYR'",
"expected_accepted": true,
"expected_output": "RBGYR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBBGYR'",
"expected_accepted": true,
"expected_output": "RBBGYR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'RY' should output 'RYBGYR'",
"expected_accepted": true,
"expected_output": "RYBGYR",
"input": "RY"
},
{
"check_output": true,
"description": "Input 'GG' should output 'GGBGYR'",
"expected_accepted": true,
"expected_output": "GGBGYR",
"input": "GG"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRBGYR'",
"expected_accepted": true,
"expected_output": "BBRBGYR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRBGYR'",
"expected_accepted": true,
"expected_output": "RBRBGYR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBBGYR'",
"expected_accepted": true,
"expected_output": "RRBBGYR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' should output 'BBGYR'",
"expected_accepted": true,
"expected_output": "BBGYR",
"input": "B"
},
{
"check_output": true,
"description": "Input 'YR' should output 'YRBGYR'",
"expected_accepted": true,
"expected_output": "YRBGYR",
"input": "YR"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBBGYR'",
"expected_accepted": true,
"expected_output": "BRBBGYR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRBGYR'",
"expected_accepted": true,
"expected_output": "BRBGYR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BGGR' should output 'BGGRBGYR'",
"expected_accepted": true,
"expected_output": "BGGRBGYR",
"input": "BGGR"
},
{
"check_output": true,
"description": "Input 'BBGGGGYB' should output 'BBGGGGYBBGYR'",
"expected_accepted": true,
"expected_output": "BBGGGGYBBGYR",
"input": "BBGGGGYB"
},
{
"check_output": true,
"description": "Input 'YGBBGBBGBBRG' should output 'YGBBGBBGBBRGBGYR'",
"expected_accepted": true,
"expected_output": "YGBBGBBGBBRGBGYR",
"input": "YGBBGBBGBBRG"
},
{
"check_output": true,
"description": "Input 'GGRBBGYYYRGRYGR' should output 'GGRBBGYYYRGRYGRBGYR'",
"expected_accepted": true,
"expected_output": "GGRBBGYYYRGRYGRBGYR",
"input": "GGRBBGYYYRGRYGR"
}
] |
manufactoria
|
basic
|
6227ed36-c79d-4f2e-a05b-804e3d84933d
|
append_sequence
|
Append BGYR
|
[
{
"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\nAccept any input and append the sequence 'YRRBYR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'YRRBYR'",
"expected_accepted": true,
"expected_output": "YRRBYR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RYRRBYR'",
"expected_accepted": true,
"expected_output": "RYRRBYR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBYRRBYR'",
"expected_accepted": true,
"expected_output": "RBYRRBYR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'RY' should output 'RYYRRBYR'",
"expected_accepted": true,
"expected_output": "RYYRRBYR",
"input": "RY"
},
{
"check_output": true,
"description": "Input 'GR' should output 'GRYRRBYR'",
"expected_accepted": true,
"expected_output": "GRYRRBYR",
"input": "GR"
},
{
"check_output": true,
"description": "Input 'BY' should output 'BYYRRBYR'",
"expected_accepted": true,
"expected_output": "BYYRRBYR",
"input": "BY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRYRRBYR'",
"expected_accepted": true,
"expected_output": "BBRYRRBYR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRYRRBYR'",
"expected_accepted": true,
"expected_output": "RBRYRRBYR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBYRRBYR'",
"expected_accepted": true,
"expected_output": "RRBYRRBYR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBYRRBYR'",
"expected_accepted": true,
"expected_output": "BRBYRRBYR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRYRRBYR'",
"expected_accepted": true,
"expected_output": "BRYRRBYR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RG' should output 'RGYRRBYR'",
"expected_accepted": true,
"expected_output": "RGYRRBYR",
"input": "RG"
},
{
"check_output": true,
"description": "Input 'RGBB' should output 'RGBBYRRBYR'",
"expected_accepted": true,
"expected_output": "RGBBYRRBYR",
"input": "RGBB"
},
{
"check_output": true,
"description": "Input 'YYGBBGRR' should output 'YYGBBGRRYRRBYR'",
"expected_accepted": true,
"expected_output": "YYGBBGRRYRRBYR",
"input": "YYGBBGRR"
},
{
"check_output": true,
"description": "Input 'BRYBYGRYGRGR' should output 'BRYBYGRYGRGRYRRBYR'",
"expected_accepted": true,
"expected_output": "BRYBYGRYGRGRYRRBYR",
"input": "BRYBYGRYGRGR"
},
{
"check_output": true,
"description": "Input 'GRGBBBYGYBRGGYY' should output 'GRGBBBYGYBRGGYYYRRBYR'",
"expected_accepted": true,
"expected_output": "GRGBBBYGYBRGGYYYRRBYR",
"input": "GRGBBBYGYBRGGYY"
}
] |
manufactoria
|
basic
|
5c6e41e7-9bf1-442a-aa1f-3f139df2793c
|
append_sequence
|
Append YRRBYR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly BBBRRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRRRRBBRBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBBRBBBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBBBRRRRRRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBRRBRBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBRBRBBRRRRR"
}
] |
manufactoria
|
basic
|
0912bd7e-2f6d-4827-8ab6-2560398ef1c5
|
exact_sequence
|
Exactly BBBRRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly RRBBR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBRRRBBBRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBRRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRBBRRBBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRBRBRBBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBBRBBRRBRB"
}
] |
manufactoria
|
basic
|
9722502a-ab03-4524-af6b-851927e5c6f2
|
exact_sequence
|
Exactly RRBBR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with RRRBRB; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRBRBRBBRRBRBRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRBRBRRRBRBRRRBRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRBRBRRBBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBBBBBBB"
}
] |
manufactoria
|
basic
|
24ecd2a2-65f2-43a9-8e68-63e8bd3d1f80
|
starts_with
|
Starts with RRRBRB
|
[
{
"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\nAccept any input and append the sequence 'BYGRYR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'BYGRYR'",
"expected_accepted": true,
"expected_output": "BYGRYR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RBYGRYR'",
"expected_accepted": true,
"expected_output": "RBYGRYR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBBYGRYR'",
"expected_accepted": true,
"expected_output": "RBBYGRYR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'GG' should output 'GGBYGRYR'",
"expected_accepted": true,
"expected_output": "GGBYGRYR",
"input": "GG"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRBYGRYR'",
"expected_accepted": true,
"expected_output": "BBRBYGRYR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRBYGRYR'",
"expected_accepted": true,
"expected_output": "RBRBYGRYR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'YG' should output 'YGBYGRYR'",
"expected_accepted": true,
"expected_output": "YGBYGRYR",
"input": "YG"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBBYGRYR'",
"expected_accepted": true,
"expected_output": "RRBBYGRYR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'G' should output 'GBYGRYR'",
"expected_accepted": true,
"expected_output": "GBYGRYR",
"input": "G"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBBYGRYR'",
"expected_accepted": true,
"expected_output": "BRBBYGRYR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRBYGRYR'",
"expected_accepted": true,
"expected_output": "BRBYGRYR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' should output 'BBBYGRYR'",
"expected_accepted": true,
"expected_output": "BBBYGRYR",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'BYYB' should output 'BYYBBYGRYR'",
"expected_accepted": true,
"expected_output": "BYYBBYGRYR",
"input": "BYYB"
},
{
"check_output": true,
"description": "Input 'YRYRGYRY' should output 'YRYRGYRYBYGRYR'",
"expected_accepted": true,
"expected_output": "YRYRGYRYBYGRYR",
"input": "YRYRGYRY"
},
{
"check_output": true,
"description": "Input 'YYYYYBGRGRYG' should output 'YYYYYBGRGRYGBYGRYR'",
"expected_accepted": true,
"expected_output": "YYYYYBGRGRYGBYGRYR",
"input": "YYYYYBGRGRYG"
},
{
"check_output": true,
"description": "Input 'BBBRBBGBYYBBBRB' should output 'BBBRBBGBYYBBBRBBYGRYR'",
"expected_accepted": true,
"expected_output": "BBBRBBGBYYBBBRBBYGRYR",
"input": "BBBRBBGBYYBBBRB"
}
] |
manufactoria
|
basic
|
dffcdba8-c4dc-4d23-987c-a888a4031930
|
append_sequence
|
Append BYGRYR
|
[
{
"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\nAccept any input and append the sequence 'RGYBRY' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RGYBRY'",
"expected_accepted": true,
"expected_output": "RGYBRY",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRGYBRY'",
"expected_accepted": true,
"expected_output": "RRGYBRY",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRGYBRY'",
"expected_accepted": true,
"expected_output": "RBRGYBRY",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'GR' should output 'GRRGYBRY'",
"expected_accepted": true,
"expected_output": "GRRGYBRY",
"input": "GR"
},
{
"check_output": true,
"description": "Input 'BY' should output 'BYRGYBRY'",
"expected_accepted": true,
"expected_output": "BYRGYBRY",
"input": "BY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRGYBRY'",
"expected_accepted": true,
"expected_output": "BBRRGYBRY",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRGYBRY'",
"expected_accepted": true,
"expected_output": "RBRRGYBRY",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'YG' should output 'YGRGYBRY'",
"expected_accepted": true,
"expected_output": "YGRGYBRY",
"input": "YG"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRGYBRY'",
"expected_accepted": true,
"expected_output": "RRBRGYBRY",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'YR' should output 'YRRGYBRY'",
"expected_accepted": true,
"expected_output": "YRRGYBRY",
"input": "YR"
},
{
"check_output": true,
"description": "Input 'RR' should output 'RRRGYBRY'",
"expected_accepted": true,
"expected_output": "RRRGYBRY",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRGYBRY'",
"expected_accepted": true,
"expected_output": "BRRGYBRY",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRGYBRY'",
"expected_accepted": true,
"expected_output": "BRBRGYBRY",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BBYR' should output 'BBYRRGYBRY'",
"expected_accepted": true,
"expected_output": "BBYRRGYBRY",
"input": "BBYR"
},
{
"check_output": true,
"description": "Input 'RBGGBYRB' should output 'RBGGBYRBRGYBRY'",
"expected_accepted": true,
"expected_output": "RBGGBYRBRGYBRY",
"input": "RBGGBYRB"
},
{
"check_output": true,
"description": "Input 'YYYGYBBBYYGG' should output 'YYYGYBBBYYGGRGYBRY'",
"expected_accepted": true,
"expected_output": "YYYGYBBBYYGGRGYBRY",
"input": "YYYGYBBBYYGG"
},
{
"check_output": true,
"description": "Input 'GBRBBGYRGBRYRBR' should output 'GBRBBGYRGBRYRBRRGYBRY'",
"expected_accepted": true,
"expected_output": "GBRBBGYRGBRYRBRRGYBRY",
"input": "GBRBBGYRGBRYRBR"
}
] |
manufactoria
|
basic
|
39316fb5-7471-4713-97a4-8c79f8986ca2
|
append_sequence
|
Append RGYBRY
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly BBBRBR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRBRBRBBRBRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBRRRBBBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBBBRBRBRBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBRBRBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBBBRBRBBBR"
}
] |
manufactoria
|
basic
|
901421eb-5efc-4ab1-a4b6-62dadfbae3e3
|
exact_sequence
|
Exactly BBBRBR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with RBBRRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBRRRRRRRBBRRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBRRRRBBRRRRBBRRRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRRRRBRBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBBBBBBB"
}
] |
manufactoria
|
basic
|
7aa8d336-b348-4679-9d81-3827a6fcc28f
|
starts_with
|
Starts with RBBRRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with BRBRRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBRRRRRBBBBBRBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBRRRBRBRRRBRBRRRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBRRRRRBRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRRRRRRRR"
}
] |
manufactoria
|
basic
|
1163752b-f3ec-4855-8669-fb9fafc8b666
|
starts_with
|
Starts with BRBRRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with RRBRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRBRRBBBBBRRBBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRBRRRRBRRRRBRRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBRRRBBBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBBBBBBB"
}
] |
manufactoria
|
basic
|
829811de-a656-4cd7-a258-44335b3874a1
|
starts_with
|
Starts with RRBRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with RRRRRB; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRRRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRRRBBRRBRRBRBRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRRRBRRRRRBRRRRRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRRRBBBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBBBBBBB"
}
] |
manufactoria
|
basic
|
e6701c8a-9b98-45fc-9cab-7c024e9f44a3
|
starts_with
|
Starts with RRRRRB
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with BRRRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRRRRRBRBRBRBRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRRRRBRRRRBRRRRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRBBRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRRRRRRRR"
}
] |
manufactoria
|
basic
|
3cbf7b2c-8def-4df6-b8fb-7918a621a2ea
|
starts_with
|
Starts with BRRRR
|
[
{
"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\nAccept any input and append the sequence 'GBBBYR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'GBBBYR'",
"expected_accepted": true,
"expected_output": "GBBBYR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RGBBBYR'",
"expected_accepted": true,
"expected_output": "RGBBBYR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBGBBBYR'",
"expected_accepted": true,
"expected_output": "RBGBBBYR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRGBBBYR'",
"expected_accepted": true,
"expected_output": "BBRGBBBYR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRGBBBYR'",
"expected_accepted": true,
"expected_output": "RBRGBBBYR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBGBBBYR'",
"expected_accepted": true,
"expected_output": "RRBGBBBYR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'B' should output 'BGBBBYR'",
"expected_accepted": true,
"expected_output": "BGBBBYR",
"input": "B"
},
{
"check_output": true,
"description": "Input 'YR' should output 'YRGBBBYR'",
"expected_accepted": true,
"expected_output": "YRGBBBYR",
"input": "YR"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBGBBBYR'",
"expected_accepted": true,
"expected_output": "BRBGBBBYR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRGBBBYR'",
"expected_accepted": true,
"expected_output": "BRGBBBYR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' should output 'BBGBBBYR'",
"expected_accepted": true,
"expected_output": "BBGBBBYR",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'RG' should output 'RGGBBBYR'",
"expected_accepted": true,
"expected_output": "RGGBBBYR",
"input": "RG"
},
{
"check_output": true,
"description": "Input 'BBBY' should output 'BBBYGBBBYR'",
"expected_accepted": true,
"expected_output": "BBBYGBBBYR",
"input": "BBBY"
},
{
"check_output": true,
"description": "Input 'RGGGRBGR' should output 'RGGGRBGRGBBBYR'",
"expected_accepted": true,
"expected_output": "RGGGRBGRGBBBYR",
"input": "RGGGRBGR"
},
{
"check_output": true,
"description": "Input 'BRBBBRRRBGBG' should output 'BRBBBRRRBGBGGBBBYR'",
"expected_accepted": true,
"expected_output": "BRBBBRRRBGBGGBBBYR",
"input": "BRBBBRRRBGBG"
},
{
"check_output": true,
"description": "Input 'BYGGYGYRRGRRYYR' should output 'BYGGYGYRRGRRYYRGBBBYR'",
"expected_accepted": true,
"expected_output": "BYGGYGYRRGRRYYRGBBBYR",
"input": "BYGGYGYRRGRRYYR"
}
] |
manufactoria
|
basic
|
4994ed77-633e-4ac9-8f2c-5f55a32ed156
|
append_sequence
|
Append GBBBYR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly RRB; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBBBRBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBBBRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRBBBBRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRRBBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBRRBBRRBRB"
}
] |
manufactoria
|
basic
|
3b759262-e2eb-421b-8ccf-eb80d41b10a0
|
exact_sequence
|
Exactly RRB
|
[
{
"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\nAccept any input and append the sequence 'RBYGRR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RBYGRR'",
"expected_accepted": true,
"expected_output": "RBYGRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRBYGRR'",
"expected_accepted": true,
"expected_output": "RRBYGRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRBYGRR'",
"expected_accepted": true,
"expected_output": "RBRBYGRR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'Y' should output 'YRBYGRR'",
"expected_accepted": true,
"expected_output": "YRBYGRR",
"input": "Y"
},
{
"check_output": true,
"description": "Input 'YY' should output 'YYRBYGRR'",
"expected_accepted": true,
"expected_output": "YYRBYGRR",
"input": "YY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRBYGRR'",
"expected_accepted": true,
"expected_output": "BBRRBYGRR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRBYGRR'",
"expected_accepted": true,
"expected_output": "RBRRBYGRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRBYGRR'",
"expected_accepted": true,
"expected_output": "RRBRBYGRR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'YR' should output 'YRRBYGRR'",
"expected_accepted": true,
"expected_output": "YRRBYGRR",
"input": "YR"
},
{
"check_output": true,
"description": "Input 'G' should output 'GRBYGRR'",
"expected_accepted": true,
"expected_output": "GRBYGRR",
"input": "G"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRBYGRR'",
"expected_accepted": true,
"expected_output": "BRBRBYGRR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRBYGRR'",
"expected_accepted": true,
"expected_output": "BRRBYGRR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BB' should output 'BBRBYGRR'",
"expected_accepted": true,
"expected_output": "BBRBYGRR",
"input": "BB"
},
{
"check_output": true,
"description": "Input 'YGYY' should output 'YGYYRBYGRR'",
"expected_accepted": true,
"expected_output": "YGYYRBYGRR",
"input": "YGYY"
},
{
"check_output": true,
"description": "Input 'YYYBBGBB' should output 'YYYBBGBBRBYGRR'",
"expected_accepted": true,
"expected_output": "YYYBBGBBRBYGRR",
"input": "YYYBBGBB"
},
{
"check_output": true,
"description": "Input 'BGYRRRGGYBBR' should output 'BGYRRRGGYBBRRBYGRR'",
"expected_accepted": true,
"expected_output": "BGYRRRGGYBBRRBYGRR",
"input": "BGYRRRGGYBBR"
},
{
"check_output": true,
"description": "Input 'GYRBRRRGYYBYRRR' should output 'GYRBRRRGYYBYRRRRBYGRR'",
"expected_accepted": true,
"expected_output": "GYRBRRRGYYBYRRRRBYGRR",
"input": "GYRBRRRGYYBYRRR"
}
] |
manufactoria
|
basic
|
3ab2bab1-e429-4de7-a695-509a7e95b500
|
append_sequence
|
Append RBYGRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with RBBBRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBBRRRBBRRRBRBRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBBRRRBBBRRRBBBRRBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBRRBRRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBBBBBBBBBB"
}
] |
manufactoria
|
basic
|
f92c382c-00b3-4847-979f-ce3d4e1f31d3
|
starts_with
|
Starts with RBBBRR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly RBBR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRBBRRBBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRRBRRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBRBBRBBRBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRRRBRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRBRBRBBBBB"
}
] |
manufactoria
|
basic
|
6f8fe57d-0b75-4050-9f1c-5c3513292820
|
exact_sequence
|
Exactly RBBR
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly RBRBRR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RBRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBRRRRBRBBRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBRBRRRBRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRBRBRRBBRRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRRRRBRRBBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRRBBRBBRRB"
}
] |
manufactoria
|
basic
|
7d46141a-59b8-4a35-a4af-51ef09e34b4b
|
exact_sequence
|
Exactly RBRBRR
|
[
{
"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\nAccept any input and append the sequence 'GRBGGY' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'GRBGGY'",
"expected_accepted": true,
"expected_output": "GRBGGY",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RGRBGGY'",
"expected_accepted": true,
"expected_output": "RGRBGGY",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBGRBGGY'",
"expected_accepted": true,
"expected_output": "RBGRBGGY",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'RY' should output 'RYGRBGGY'",
"expected_accepted": true,
"expected_output": "RYGRBGGY",
"input": "RY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRGRBGGY'",
"expected_accepted": true,
"expected_output": "BBRGRBGGY",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRGRBGGY'",
"expected_accepted": true,
"expected_output": "RBRGRBGGY",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBGRBGGY'",
"expected_accepted": true,
"expected_output": "RRBGRBGGY",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'GB' should output 'GBGRBGGY'",
"expected_accepted": true,
"expected_output": "GBGRBGGY",
"input": "GB"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBGRBGGY'",
"expected_accepted": true,
"expected_output": "BRBGRBGGY",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRGRBGGY'",
"expected_accepted": true,
"expected_output": "BRGRBGGY",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'YB' should output 'YBGRBGGY'",
"expected_accepted": true,
"expected_output": "YBGRBGGY",
"input": "YB"
},
{
"check_output": true,
"description": "Input 'RGGG' should output 'RGGGGRBGGY'",
"expected_accepted": true,
"expected_output": "RGGGGRBGGY",
"input": "RGGG"
},
{
"check_output": true,
"description": "Input 'RYRGGYRR' should output 'RYRGGYRRGRBGGY'",
"expected_accepted": true,
"expected_output": "RYRGGYRRGRBGGY",
"input": "RYRGGYRR"
},
{
"check_output": true,
"description": "Input 'YGGGYGGGBYBG' should output 'YGGGYGGGBYBGGRBGGY'",
"expected_accepted": true,
"expected_output": "YGGGYGGGBYBGGRBGGY",
"input": "YGGGYGGGBYBG"
},
{
"check_output": true,
"description": "Input 'RYBBBGGRGGRYRGG' should output 'RYBBBGGRGGRYRGGGRBGGY'",
"expected_accepted": true,
"expected_output": "RYBBBGGRGGRYRGGGRBGGY",
"input": "RYBBBGGRGGRYRGG"
}
] |
manufactoria
|
basic
|
02b4e569-08ab-4e92-a42f-84f71d64aafa
|
append_sequence
|
Append GRBGGY
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with BRBBR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBBRRBBRRRBBRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BRBBRBRBBRBRBBRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRBBRBRRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRRRRRRRR"
}
] |
manufactoria
|
basic
|
a81bf480-d969-4e4d-b738-05a92deccb19
|
starts_with
|
Starts with BRBBR
|
[
{
"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\nAccept any input and append the sequence 'RGYBB' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RGYBB'",
"expected_accepted": true,
"expected_output": "RGYBB",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRGYBB'",
"expected_accepted": true,
"expected_output": "RRGYBB",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRGYBB'",
"expected_accepted": true,
"expected_output": "RBRGYBB",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'Y' should output 'YRGYBB'",
"expected_accepted": true,
"expected_output": "YRGYBB",
"input": "Y"
},
{
"check_output": true,
"description": "Input 'YY' should output 'YYRGYBB'",
"expected_accepted": true,
"expected_output": "YYRGYBB",
"input": "YY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRGYBB'",
"expected_accepted": true,
"expected_output": "BBRRGYBB",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRGYBB'",
"expected_accepted": true,
"expected_output": "RBRRGYBB",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRGYBB'",
"expected_accepted": true,
"expected_output": "RRBRGYBB",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'G' should output 'GRGYBB'",
"expected_accepted": true,
"expected_output": "GRGYBB",
"input": "G"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRGYBB'",
"expected_accepted": true,
"expected_output": "BRBRGYBB",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRGYBB'",
"expected_accepted": true,
"expected_output": "BRRGYBB",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'RG' should output 'RGRGYBB'",
"expected_accepted": true,
"expected_output": "RGRGYBB",
"input": "RG"
},
{
"check_output": true,
"description": "Input 'GBGB' should output 'GBGBRGYBB'",
"expected_accepted": true,
"expected_output": "GBGBRGYBB",
"input": "GBGB"
},
{
"check_output": true,
"description": "Input 'BGRBGYGB' should output 'BGRBGYGBRGYBB'",
"expected_accepted": true,
"expected_output": "BGRBGYGBRGYBB",
"input": "BGRBGYGB"
},
{
"check_output": true,
"description": "Input 'YRYBBYGBGYYY' should output 'YRYBBYGBGYYYRGYBB'",
"expected_accepted": true,
"expected_output": "YRYBBYGBGYYYRGYBB",
"input": "YRYBBYGBGYYY"
},
{
"check_output": true,
"description": "Input 'BYGGYGRGGGRGGRB' should output 'BYGGYGRGGGRGGRBRGYBB'",
"expected_accepted": true,
"expected_output": "BYGGYGRGGGRGGRBRGYBB",
"input": "BYGGYGRGGGRGGRB"
}
] |
manufactoria
|
basic
|
81deb2e9-5928-4262-b54b-ca0d5205e77c
|
append_sequence
|
Append RGYBB
|
[
{
"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\nAccept any input and append the sequence 'RYRBGG' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RYRBGG'",
"expected_accepted": true,
"expected_output": "RYRBGG",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRYRBGG'",
"expected_accepted": true,
"expected_output": "RRYRBGG",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRYRBGG'",
"expected_accepted": true,
"expected_output": "RBRYRBGG",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'GR' should output 'GRRYRBGG'",
"expected_accepted": true,
"expected_output": "GRRYRBGG",
"input": "GR"
},
{
"check_output": true,
"description": "Input 'GG' should output 'GGRYRBGG'",
"expected_accepted": true,
"expected_output": "GGRYRBGG",
"input": "GG"
},
{
"check_output": true,
"description": "Input 'YY' should output 'YYRYRBGG'",
"expected_accepted": true,
"expected_output": "YYRYRBGG",
"input": "YY"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRYRBGG'",
"expected_accepted": true,
"expected_output": "BBRRYRBGG",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRYRBGG'",
"expected_accepted": true,
"expected_output": "RBRRYRBGG",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRYRBGG'",
"expected_accepted": true,
"expected_output": "RRBRYRBGG",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'RR' should output 'RRRYRBGG'",
"expected_accepted": true,
"expected_output": "RRRYRBGG",
"input": "RR"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRYRBGG'",
"expected_accepted": true,
"expected_output": "BRRYRBGG",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRYRBGG'",
"expected_accepted": true,
"expected_output": "BRBRYRBGG",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'YBRB' should output 'YBRBRYRBGG'",
"expected_accepted": true,
"expected_output": "YBRBRYRBGG",
"input": "YBRB"
},
{
"check_output": true,
"description": "Input 'RGRGBYYR' should output 'RGRGBYYRRYRBGG'",
"expected_accepted": true,
"expected_output": "RGRGBYYRRYRBGG",
"input": "RGRGBYYR"
},
{
"check_output": true,
"description": "Input 'YBYRYYBRBYYR' should output 'YBYRYYBRBYYRRYRBGG'",
"expected_accepted": true,
"expected_output": "YBYRYYBRBYYRRYRBGG",
"input": "YBYRYYBRBYYR"
},
{
"check_output": true,
"description": "Input 'BGBRRYBBYYGBYGG' should output 'BGBRRYBBYYGBYGGRYRBGG'",
"expected_accepted": true,
"expected_output": "BGBRRYBBYYGBYGGRYRBGG",
"input": "BGBRRYBBYYGBYGG"
}
] |
manufactoria
|
basic
|
9a78facd-3948-4708-bd9e-c133fc8d2036
|
append_sequence
|
Append RYRBGG
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape is exactly RRRBBR; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "RRRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRBB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRBBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRBBRRBRBRRRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRBRRRBBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRRRRBBRRRBRRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRBRBBBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRBRRRRBBBRB"
}
] |
manufactoria
|
basic
|
7af450d2-d8f5-4969-8ec8-3812c98c369c
|
exact_sequence
|
Exactly RRRBBR
|
[
{
"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\nAccept any input and append the sequence 'RBBYRR' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RBBYRR'",
"expected_accepted": true,
"expected_output": "RBBYRR",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRBBYRR'",
"expected_accepted": true,
"expected_output": "RRBBYRR",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRBBYRR'",
"expected_accepted": true,
"expected_output": "RBRBBYRR",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'RY' should output 'RYRBBYRR'",
"expected_accepted": true,
"expected_output": "RYRBBYRR",
"input": "RY"
},
{
"check_output": true,
"description": "Input 'BG' should output 'BGRBBYRR'",
"expected_accepted": true,
"expected_output": "BGRBBYRR",
"input": "BG"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRBBYRR'",
"expected_accepted": true,
"expected_output": "BBRRBBYRR",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRBBYRR'",
"expected_accepted": true,
"expected_output": "RBRRBBYRR",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRBBYRR'",
"expected_accepted": true,
"expected_output": "RRBRBBYRR",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRBBYRR'",
"expected_accepted": true,
"expected_output": "BRBRBBYRR",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRBBYRR'",
"expected_accepted": true,
"expected_output": "BRRBBYRR",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'YRYY' should output 'YRYYRBBYRR'",
"expected_accepted": true,
"expected_output": "YRYYRBBYRR",
"input": "YRYY"
},
{
"check_output": true,
"description": "Input 'GGGYRRGB' should output 'GGGYRRGBRBBYRR'",
"expected_accepted": true,
"expected_output": "GGGYRRGBRBBYRR",
"input": "GGGYRRGB"
},
{
"check_output": true,
"description": "Input 'RBGRBRBBYGRY' should output 'RBGRBRBBYGRYRBBYRR'",
"expected_accepted": true,
"expected_output": "RBGRBRBBYGRYRBBYRR",
"input": "RBGRBRBBYGRY"
},
{
"check_output": true,
"description": "Input 'RYRBBGYBGYRRYRR' should output 'RYRBBGYBGYRRYRRRBBYRR'",
"expected_accepted": true,
"expected_output": "RYRBBGYBGYRRYRRRBBYRR",
"input": "RYRBBGYBGYRRYRR"
}
] |
manufactoria
|
basic
|
f756432f-93b3-458b-b1f6-4bfcc22a5961
|
append_sequence
|
Append RBBYRR
|
[
{
"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\nAccept any input and append the sequence 'RRGBRG' to the end of the tape.",
"role": "user"
}
] |
[
{
"check_output": true,
"description": "Input '' should output 'RRGBRG'",
"expected_accepted": true,
"expected_output": "RRGBRG",
"input": ""
},
{
"check_output": true,
"description": "Input 'R' should output 'RRRGBRG'",
"expected_accepted": true,
"expected_output": "RRRGBRG",
"input": "R"
},
{
"check_output": true,
"description": "Input 'RB' should output 'RBRRGBRG'",
"expected_accepted": true,
"expected_output": "RBRRGBRG",
"input": "RB"
},
{
"check_output": true,
"description": "Input 'GG' should output 'GGRRGBRG'",
"expected_accepted": true,
"expected_output": "GGRRGBRG",
"input": "GG"
},
{
"check_output": true,
"description": "Input 'BBR' should output 'BBRRRGBRG'",
"expected_accepted": true,
"expected_output": "BBRRRGBRG",
"input": "BBR"
},
{
"check_output": true,
"description": "Input 'GY' should output 'GYRRGBRG'",
"expected_accepted": true,
"expected_output": "GYRRGBRG",
"input": "GY"
},
{
"check_output": true,
"description": "Input 'RBR' should output 'RBRRRGBRG'",
"expected_accepted": true,
"expected_output": "RBRRRGBRG",
"input": "RBR"
},
{
"check_output": true,
"description": "Input 'RRB' should output 'RRBRRGBRG'",
"expected_accepted": true,
"expected_output": "RRBRRGBRG",
"input": "RRB"
},
{
"check_output": true,
"description": "Input 'BRB' should output 'BRBRRGBRG'",
"expected_accepted": true,
"expected_output": "BRBRRGBRG",
"input": "BRB"
},
{
"check_output": true,
"description": "Input 'BR' should output 'BRRRGBRG'",
"expected_accepted": true,
"expected_output": "BRRRGBRG",
"input": "BR"
},
{
"check_output": true,
"description": "Input 'GBRY' should output 'GBRYRRGBRG'",
"expected_accepted": true,
"expected_output": "GBRYRRGBRG",
"input": "GBRY"
},
{
"check_output": true,
"description": "Input 'RYGRBGRR' should output 'RYGRBGRRRRGBRG'",
"expected_accepted": true,
"expected_output": "RYGRBGRRRRGBRG",
"input": "RYGRBGRR"
},
{
"check_output": true,
"description": "Input 'BRBBYYYRGGRG' should output 'BRBBYYYRGGRGRRGBRG'",
"expected_accepted": true,
"expected_output": "BRBBYYYRGGRGRRGBRG",
"input": "BRBBYYYRGGRG"
},
{
"check_output": true,
"description": "Input 'YBBYBGYYBBRBBGY' should output 'YBBYBGYYBBRBBGYRRGBRG'",
"expected_accepted": true,
"expected_output": "YBBYBGYYBBRBBGYRRGBRG",
"input": "YBBYBGYYBBRBBGY"
}
] |
manufactoria
|
basic
|
807e94db-9919-4f0a-be4f-3b14f2c8f27c
|
append_sequence
|
Append RRGBRG
|
[
{
"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\nRoute robots to the correct destinations based on their final tape configuration and the puzzle requirements:\n- **Accepted**: Robot reaches the END node\n- **Rejected**: Robot is not routed to the END node or caught in an infinite loop. \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\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\nAccept if the tape starts with BBRBRB; reject otherwise. The input tape carries only red/blue colors.",
"role": "user"
}
] |
[
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": ""
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "R"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "B"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "BRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBRBRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBBRBRB"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBRBRBRRBBRRBBRRBR"
},
{
"check_output": false,
"description": "",
"expected_accepted": true,
"expected_output": "",
"input": "BBRBRBBBRBRBBBRBRBRRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RBRBRBBBRBRR"
},
{
"check_output": false,
"description": "",
"expected_accepted": false,
"expected_output": "",
"input": "RRRRRRRRRRRR"
}
] |
manufactoria
|
basic
|
4911c537-88b0-4adb-b3e0-2861fc667c50
|
starts_with
|
Starts with BBRBRB
|
- Downloads last month
- 22