question
stringlengths 99
1.29k
| answer
stringlengths 1
164
| source_dataset
stringclasses 10
values | metadata_json
stringlengths 73
802
|
|---|---|---|---|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:9, B:5, C:9
And your target is: 6 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "fill B", "pour B->A", "pour B->C", "pour A->B", "pour B->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [9, 5, 9], "min_moves": 7, "target": 6}, "source_dataset": "jugs", "source_index": 93}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
azye yhgr
|
True
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": true, "solvable": true, "source_dataset": "isomorphic_strings", "source_index": 80, "string_length": 5, "words": ["azye", "yhgr"]}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:7, B:9, C:9
And your target is: 8 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "empty A", "pour B->A", "fill B", "pour B->A", "empty A", "pour B->A", "fill B", "pour B->A", "empty A", "pour B->A", "fill B", "pour B->A"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [7, 9, 9], "min_moves": 14, "target": 8}, "source_dataset": "jugs", "source_index": 91}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
ddzkhs zfczdw
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 79, "string_length": 6, "words": ["ddzkhs", "zfczdw"]}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 450 degrees clockwise:
6 5 0
9 0 8
0 0 4
|
0 9 6
0 0 5
4 8 0
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[6, 5, 0], [9, 0, 8], [0, 0, 4]], "n": 3, "num_rotations": 5, "solution": [[0, 9, 6], [0, 0, 5], [4, 8, 0]], "source_dataset": "rotate_matrix", "source_index": 19}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
#B B# #B B# B# B# A# #B #B A#
Return the final state of the program.
|
#B B# A# A#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 89}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:5, B:9, C:9
And your target is: 3 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "empty A", "pour B->A", "fill B", "pour B->A", "empty A", "pour B->A"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [5, 9, 9], "min_moves": 8, "target": 3}, "source_dataset": "jugs", "source_index": 29}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-12 number 133 to base-11
|
157
|
base_conversion
|
{"decimal_value": 183, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 12, "source_dataset": "base_conversion", "source_index": 95, "source_repr": "133", "target_base": 11, "target_repr": "157"}
|
Decrypt this Caesar cipher text: KOG KWHV RF. Provide only the decrypted text as your final answer.
|
WAS WITH DR
|
caesar_cipher
|
{"cipher_text": "KOG KWHV RF", "clear_text": "WAS WITH DR", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 3, "rotation": 14, "source_dataset": "caesar_cipher", "source_index": 82}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 1 1
1 1 0
1 1 0
|
3 2 1
2 1 0
2 1 0
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 1, 1], [1, 1, 0], [1, 1, 0]], "n": 3, "solution": [[3, 2, 1], [2, 1, 0], [2, 1, 0]], "source_dataset": "binary_matrix", "source_index": 93}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:6, B:6, C:5
And your target is: 2 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill A", "pour A->C", "fill B", "empty C", "pour A->C", "pour B->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [6, 6, 5], "min_moves": 6, "target": 2}, "source_dataset": "jugs", "source_index": 79}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string contains 'ca' (not at the start), remove the first occurrence found after the first character.
2. If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.
3. If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
ccbcbccbcbacac
|
ccbcbccbcbac
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 3, "selected_rules": ["If the string contains 'ca' (not at the start), remove the first occurrence found after the first character.", "If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.", "If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end."], "solution": "ccbcbccbcbac", "source_dataset": "string_manipulation", "source_index": 76, "states": ["ccbcbccbcbacac", "ccbcbccbcbac"], "string": "ccbcbccbcbacac", "string_length": 14}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
#B B# #A B# A# A# #A #B B# B#
Return the final state of the program.
|
#B #A B# A# B# B#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 18}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:3, B:7, C:7
And your target is: 5 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "empty A", "pour B->A", "empty A", "pour B->A", "fill B", "pour B->A"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [3, 7, 7], "min_moves": 8, "target": 5}, "source_dataset": "jugs", "source_index": 50}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 1
0 1
|
1 2
0 1
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 1], [0, 1]], "n": 2, "solution": [[1, 2], [0, 1]], "source_dataset": "binary_matrix", "source_index": 16}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-8 number 426 to base-10
|
278
|
base_conversion
|
{"decimal_value": 278, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 8, "source_dataset": "base_conversion", "source_index": 9, "source_repr": "426", "target_base": 10, "target_repr": "278"}
|
Solve this cryptarithm:
NVIW
VGQ
+ NWV
------
IDVW
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
D=4,G=3,I=7,N=5,Q=1,V=9,W=8
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"1": "Q", "3": "G", "4": "D", "5": "N", "7": "I", "8": "W", "9": "V"}, "letter_to_digit": {"D": 4, "G": 3, "I": 7, "N": 5, "Q": 1, "V": 9, "W": 8}, "letters": ["I", "W", "D", "Q", "N", "V", "G"], "result_letters": "IDVW", "source_dataset": "cryptarithm", "source_index": 75, "sum_number": 7498, "word_values": [5978, 931, 589], "words_letters": ["NVIW", "VGQ", "NWV"]}
|
Decrypt this Caesar cipher text: MZP MZK MPPUFUAZMX FQDYE UYBAEQP NK FTQ OABKDUSTF TAXPQD. Provide only the decrypted text as your final answer.
|
AND ANY ADDITIONAL TERMS IMPOSED BY THE COPYRIGHT HOLDER
|
caesar_cipher
|
{"cipher_text": "MZP MZK MPPUFUAZMX FQDYE UYBAEQP NK FTQ OABKDUSTF TAXPQD", "clear_text": "AND ANY ADDITIONAL TERMS IMPOSED BY THE COPYRIGHT HOLDER", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 9, "rotation": 12, "source_dataset": "caesar_cipher", "source_index": 61}
|
Solve this cryptarithm:
FPZW
+ PJJZ
-------
UDPZU
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
D=2,F=8,J=9,P=3,U=1,W=7,Z=4
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"1": "U", "2": "D", "3": "P", "4": "Z", "7": "W", "8": "F", "9": "J"}, "letter_to_digit": {"D": 2, "F": 8, "J": 9, "P": 3, "U": 1, "W": 7, "Z": 4}, "letters": ["W", "U", "D", "Z", "P", "J", "F"], "result_letters": "UDPZU", "source_dataset": "cryptarithm", "source_index": 72, "sum_number": 12341, "word_values": [8347, 3994], "words_letters": ["FPZW", "PJJZ"]}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string starts with 'bb', remove the second character.
2. If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.
3. If the string contains 'abc', replace the first occurrence with 'cab'.
4. If the string suffix is 'cc', replace it with 'b' and prepend 'a' to the start.
5. If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
acbbaccacabbca
|
acbbaccacabbca
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 5, "selected_rules": ["If the string starts with 'bb', remove the second character.", "If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.", "If the string contains 'abc', replace the first occurrence with 'cab'.", "If the string suffix is 'cc', replace it with 'b' and prepend 'a' to the start.", "If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end."], "solution": "acbbaccacabbca", "source_dataset": "string_manipulation", "source_index": 22, "states": ["acbbaccacabbca"], "string": "acbbaccacabbca", "string_length": 14}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 001010110101100100110
|
5
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 21, "solution": 5, "solvable": true, "source_dataset": "binary_alternation", "source_index": 63, "string": "001010110101100100110"}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
ghpgx ypxzd
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 34, "string_length": 5, "words": ["ghpgx", "ypxzd"]}
|
Solve this cryptarithm:
URO
DXB
+ XXUJ
------
DJXK
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
B=1,D=9,J=5,K=6,O=0,R=2,U=8,X=7
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "O", "1": "B", "2": "R", "5": "J", "6": "K", "7": "X", "8": "U", "9": "D"}, "letter_to_digit": {"B": 1, "D": 9, "J": 5, "K": 6, "O": 0, "R": 2, "U": 8, "X": 7}, "letters": ["D", "O", "U", "R", "K", "B", "J", "X"], "result_letters": "DJXK", "source_dataset": "cryptarithm", "source_index": 78, "sum_number": 9576, "word_values": [820, 971, 7785], "words_letters": ["URO", "DXB", "XXUJ"]}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
lwnwedee csbrhehh
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 95, "string_length": 8, "words": ["lwnwedee", "csbrhehh"]}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 360 degrees clockwise:
7 2 7 4 5 5
4 0 1 4 2 9
8 3 9 8 0 7
3 1 5 8 5 1
1 7 1 4 2 0
7 6 3 5 6 1
|
7 2 7 4 5 5
4 0 1 4 2 9
8 3 9 8 0 7
3 1 5 8 5 1
1 7 1 4 2 0
7 6 3 5 6 1
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[7, 2, 7, 4, 5, 5], [4, 0, 1, 4, 2, 9], [8, 3, 9, 8, 0, 7], [3, 1, 5, 8, 5, 1], [1, 7, 1, 4, 2, 0], [7, 6, 3, 5, 6, 1]], "n": 6, "num_rotations": 4, "solution": [[7, 2, 7, 4, 5, 5], [4, 0, 1, 4, 2, 9], [8, 3, 9, 8, 0, 7], [3, 1, 5, 8, 5, 1], [1, 7, 1, 4, 2, 0], [7, 6, 3, 5, 6, 1]], "source_dataset": "rotate_matrix", "source_index": 64}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-4 number 32200 to base-15
|
41d
|
base_conversion
|
{"decimal_value": 928, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 4, "source_dataset": "base_conversion", "source_index": 72, "source_repr": "32200", "target_base": 15, "target_repr": "41d"}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string prefix is 'ab', replace it with 'ca'.
2. If the string suffix is 'bb', delete the last two characters.
3. If the string contains 'acb', replace the first occurrence with its reverse ('bca').
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
baaaabbabaaaac
|
baaaabbabaaaac
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 3, "selected_rules": ["If the string prefix is 'ab', replace it with 'ca'.", "If the string suffix is 'bb', delete the last two characters.", "If the string contains 'acb', replace the first occurrence with its reverse ('bca')."], "solution": "baaaabbabaaaac", "source_dataset": "string_manipulation", "source_index": 78, "states": ["baaaabbabaaaac"], "string": "baaaabbabaaaac", "string_length": 14}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:9, B:8, C:8
And your target is: 4 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill A", "pour A->B", "pour A->C", "fill A", "pour A->C", "empty B", "pour A->B", "fill A", "pour A->B", "empty B", "pour A->B", "fill A", "pour A->B"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [9, 8, 8], "min_moves": 13, "target": 4}, "source_dataset": "jugs", "source_index": 96}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
shcbh xtaut
|
True
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": true, "solvable": true, "source_dataset": "isomorphic_strings", "source_index": 18, "string_length": 6, "words": ["shcbh", "xtaut"]}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
#B #A A# A# #A B# B# #B A# B#
Return the final state of the program.
|
#B #A A# B# A# B#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 23}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
#A B# #B A# A# #B B# B# #A #A
Return the final state of the program.
|
#A #B B# B#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 49}
|
Decrypt this Caesar cipher text: COYN O IUARJ MKZ YUSK YRKKV. Provide only the decrypted text as your final answer.
|
WISH I COULD GET SOME SLEEP
|
caesar_cipher
|
{"cipher_text": "COYN O IUARJ MKZ YUSK YRKKV", "clear_text": "WISH I COULD GET SOME SLEEP", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 6, "rotation": 6, "source_dataset": "caesar_cipher", "source_index": 44}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 900 degrees clockwise:
9 1 5
3 3 7
5 9 3
|
3 9 5
7 3 3
5 1 9
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[9, 1, 5], [3, 3, 7], [5, 9, 3]], "n": 3, "num_rotations": 10, "solution": [[3, 9, 5], [7, 3, 3], [5, 1, 9]], "source_dataset": "rotate_matrix", "source_index": 7}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
ftxot qrtlh
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 12, "string_length": 5, "words": ["ftxot", "qrtlh"]}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
0 1 1 1 1 1
1 0 1 1 0 0
1 1 1 1 1 1
1 0 1 0 1 1
1 1 1 1 1 0
1 1 1 0 1 1
|
0 1 2 2 1 1
1 0 1 1 0 0
2 1 2 1 1 1
1 0 1 0 1 1
2 1 2 1 1 0
3 2 1 0 1 1
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[0, 1, 1, 1, 1, 1], [1, 0, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1], [1, 0, 1, 0, 1, 1], [1, 1, 1, 1, 1, 0], [1, 1, 1, 0, 1, 1]], "n": 6, "solution": [[0, 1, 2, 2, 1, 1], [1, 0, 1, 1, 0, 0], [2, 1, 2, 1, 1, 1], [1, 0, 1, 0, 1, 1], [2, 1, 2, 1, 1, 0], [3, 2, 1, 0, 1, 1]], "source_dataset": "binary_matrix", "source_index": 56}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
0 1 0 0
1 1 1 1
1 1 0 1
1 1 1 1
|
0 1 0 0
1 2 1 1
2 1 0 1
3 2 1 2
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[0, 1, 0, 0], [1, 1, 1, 1], [1, 1, 0, 1], [1, 1, 1, 1]], "n": 4, "solution": [[0, 1, 0, 0], [1, 2, 1, 1], [2, 1, 0, 1], [3, 2, 1, 2]], "source_dataset": "binary_matrix", "source_index": 46}
|
Decrypt this Caesar cipher text: FQ TXP MRYIFPEBA FK COXKZB QEB KBUQ VBXO. Provide only the decrypted text as your final answer.
|
IT WAS PUBLISHED IN FRANCE THE NEXT YEAR
|
caesar_cipher
|
{"cipher_text": "FQ TXP MRYIFPEBA FK COXKZB QEB KBUQ VBXO", "clear_text": "IT WAS PUBLISHED IN FRANCE THE NEXT YEAR", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 8, "rotation": 23, "source_dataset": "caesar_cipher", "source_index": 65}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-11 number 20a to base-14
|
140
|
base_conversion
|
{"decimal_value": 252, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 11, "source_dataset": "base_conversion", "source_index": 36, "source_repr": "20a", "target_base": 14, "target_repr": "140"}
|
Solve this cryptarithm:
HHVH
+ GIKU
-------
LIKDJ
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
D=7,G=8,H=4,I=2,J=3,K=6,L=1,U=9,V=0
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "V", "1": "L", "2": "I", "3": "J", "4": "H", "6": "K", "7": "D", "8": "G", "9": "U"}, "letter_to_digit": {"D": 7, "G": 8, "H": 4, "I": 2, "J": 3, "K": 6, "L": 1, "U": 9, "V": 0}, "letters": ["L", "G", "K", "H", "D", "I", "J", "V", "U"], "result_letters": "LIKDJ", "source_dataset": "cryptarithm", "source_index": 79, "sum_number": 12673, "word_values": [4404, 8269], "words_letters": ["HHVH", "GIKU"]}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
jd sz
|
True
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": true, "solvable": true, "source_dataset": "isomorphic_strings", "source_index": 49, "string_length": 3, "words": ["jd", "sz"]}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the binary number 111001011 to base-9
|
560
|
base_conversion
|
{"decimal_value": 459, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 2, "source_dataset": "base_conversion", "source_index": 73, "source_repr": "111001011", "target_base": 9, "target_repr": "560"}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 540 degrees clockwise:
3 8 2 3 9 7
0 7 7 0 7 0
7 9 1 9 7 0
0 4 8 4 6 7
3 5 7 8 4 6
2 7 0 7 2 3
|
3 2 7 0 7 2
6 4 8 7 5 3
7 6 4 8 4 0
0 7 9 1 9 7
0 7 0 7 7 0
7 9 3 2 8 3
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[3, 8, 2, 3, 9, 7], [0, 7, 7, 0, 7, 0], [7, 9, 1, 9, 7, 0], [0, 4, 8, 4, 6, 7], [3, 5, 7, 8, 4, 6], [2, 7, 0, 7, 2, 3]], "n": 6, "num_rotations": 6, "solution": [[3, 2, 7, 0, 7, 2], [6, 4, 8, 7, 5, 3], [7, 6, 4, 8, 4, 0], [0, 7, 9, 1, 9, 7], [0, 7, 0, 7, 7, 0], [7, 9, 3, 2, 8, 3]], "source_dataset": "rotate_matrix", "source_index": 83}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-6 number 125 to base-3
|
1222
|
base_conversion
|
{"decimal_value": 53, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 6, "source_dataset": "base_conversion", "source_index": 52, "source_repr": "125", "target_base": 3, "target_repr": "1222"}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
giys qgov
|
True
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": true, "solvable": true, "source_dataset": "isomorphic_strings", "source_index": 23, "string_length": 5, "words": ["giys", "qgov"]}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
aaaax aaafr
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 58, "string_length": 5, "words": ["aaaax", "aaafr"]}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 180 degrees clockwise:
1 4
6 2
|
2 6
4 1
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[1, 4], [6, 2]], "n": 2, "num_rotations": 2, "solution": [[2, 6], [4, 1]], "source_dataset": "rotate_matrix", "source_index": 71}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
#A #A A# #B #A A# #B A# #A A#
Return the final state of the program.
|
#A #A #B #B A# A#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 61}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-14 number 479 to base-8
|
1573
|
base_conversion
|
{"decimal_value": 891, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 14, "source_dataset": "base_conversion", "source_index": 74, "source_repr": "479", "target_base": 8, "target_repr": "1573"}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 00000010111000111001011111011
|
7
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 29, "solution": 7, "solvable": true, "source_dataset": "binary_alternation", "source_index": 85, "string": "00000010111000111001011111011"}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
A# #A A# #B #A B# #B A# A# #A
Return the final state of the program.
|
#B A#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 43}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 101001010110001101
|
4
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 18, "solution": 4, "solvable": true, "source_dataset": "binary_alternation", "source_index": 97, "string": "101001010110001101"}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 1010111001011000101010
|
3
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 22, "solution": 3, "solvable": true, "source_dataset": "binary_alternation", "source_index": 87, "string": "1010111001011000101010"}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string ends with 'ca', remove the last character.
2. If the string contains an even number of 'b's (and at least one 'b'), append 'ab' at the end.
3. If the string prefix is 'aa', remove the first character.
4. If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
bbabbcac
|
bbabbcacab
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 4, "selected_rules": ["If the string ends with 'ca', remove the last character.", "If the string contains an even number of 'b's (and at least one 'b'), append 'ab' at the end.", "If the string prefix is 'aa', remove the first character.", "If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end."], "solution": "bbabbcacab", "source_dataset": "string_manipulation", "source_index": 32, "states": ["bbabbcac", "bbabbcacab"], "string": "bbabbcac", "string_length": 8}
|
Solve this cryptarithm:
BMH
LIGZ
+ ZGV
------
IZLS
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
B=7,G=3,H=0,I=2,L=1,M=4,S=5,V=9,Z=6
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "H", "1": "L", "2": "I", "3": "G", "4": "M", "5": "S", "6": "Z", "7": "B", "9": "V"}, "letter_to_digit": {"B": 7, "G": 3, "H": 0, "I": 2, "L": 1, "M": 4, "S": 5, "V": 9, "Z": 6}, "letters": ["Z", "I", "V", "M", "L", "G", "B", "S", "H"], "result_letters": "IZLS", "source_dataset": "cryptarithm", "source_index": 13, "sum_number": 2615, "word_values": [740, 1236, 639], "words_letters": ["BMH", "LIGZ", "ZGV"]}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 1101001010110100110010
|
5
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 22, "solution": 5, "solvable": true, "source_dataset": "binary_alternation", "source_index": 38, "string": "1101001010110100110010"}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
B# B# B# B# #B B# #B A# #A #A
Return the final state of the program.
|
#A B# B# B#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 47}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 0010111100001
|
4
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 13, "solution": 4, "solvable": true, "source_dataset": "binary_alternation", "source_index": 92, "string": "0010111100001"}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string contains 'abc', replace the first occurrence with 'cab'.
2. If the string contains an even number of 'b's (and at least one 'b'), append 'ab' at the end.
3. If the string prefix is 'aa', remove the first character.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
ccacbbbbaab
|
ccacbbbbaab
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 3, "selected_rules": ["If the string contains 'abc', replace the first occurrence with 'cab'.", "If the string contains an even number of 'b's (and at least one 'b'), append 'ab' at the end.", "If the string prefix is 'aa', remove the first character."], "solution": "ccacbbbbaab", "source_dataset": "string_manipulation", "source_index": 69, "states": ["ccacbbbbaab"], "string": "ccacbbbbaab", "string_length": 11}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 1111100100010
|
4
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 13, "solution": 4, "solvable": true, "source_dataset": "binary_alternation", "source_index": 88, "string": "1111100100010"}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 10011010100011111001110010100
|
5
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 29, "solution": 5, "solvable": true, "source_dataset": "binary_alternation", "source_index": 44, "string": "10011010100011111001110010100"}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
tbiwhbc voghloj
|
True
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": true, "solvable": true, "source_dataset": "isomorphic_strings", "source_index": 98, "string_length": 8, "words": ["tbiwhbc", "voghloj"]}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 720 degrees clockwise:
3 3 9 7 1 5
3 3 4 5 5 2
1 5 4 2 4 4
4 3 3 8 8 1
6 3 3 0 1 0
7 6 6 9 6 6
|
3 3 9 7 1 5
3 3 4 5 5 2
1 5 4 2 4 4
4 3 3 8 8 1
6 3 3 0 1 0
7 6 6 9 6 6
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[3, 3, 9, 7, 1, 5], [3, 3, 4, 5, 5, 2], [1, 5, 4, 2, 4, 4], [4, 3, 3, 8, 8, 1], [6, 3, 3, 0, 1, 0], [7, 6, 6, 9, 6, 6]], "n": 6, "num_rotations": 8, "solution": [[3, 3, 9, 7, 1, 5], [3, 3, 4, 5, 5, 2], [1, 5, 4, 2, 4, 4], [4, 3, 3, 8, 8, 1], [6, 3, 3, 0, 1, 0], [7, 6, 6, 9, 6, 6]], "source_dataset": "rotate_matrix", "source_index": 42}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 10101110001100100100010101
|
-1
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 24, "solution": -1, "solvable": false, "source_dataset": "binary_alternation", "source_index": 31, "string": "10101110001100100100010101"}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:7, B:6, C:7
And your target is: 4 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "fill B", "pour B->A", "pour B->C", "pour A->B", "pour B->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [7, 6, 7], "min_moves": 7, "target": 4}, "source_dataset": "jugs", "source_index": 47}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
A# A# #A #B B# B# A# A# B# A#
Return the final state of the program.
|
#B A# B# B# A# A# B# A#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 79}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
B# A# #A B# B# #B #A B# #B B#
Return the final state of the program.
|
#A B# B# B#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 15}
|
Decrypt this Caesar cipher text: QAGCLAC MNRGAYJ QAGCLAC GQ WMSP QNCAGYJRW. Provide only the decrypted text as your final answer.
|
SCIENCE OPTICAL SCIENCE IS YOUR SPECIALTY
|
caesar_cipher
|
{"cipher_text": "QAGCLAC MNRGAYJ QAGCLAC GQ WMSP QNCAGYJRW", "clear_text": "SCIENCE OPTICAL SCIENCE IS YOUR SPECIALTY", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 6, "rotation": 24, "source_dataset": "caesar_cipher", "source_index": 13}
|
Decrypt this Caesar cipher text: RHN XGZEBLA PBEE XOXK UX MAX LTFX. Provide only the decrypted text as your final answer.
|
YOU ENGLISH WILL EVER BE THE SAME
|
caesar_cipher
|
{"cipher_text": "RHN XGZEBLA PBEE XOXK UX MAX LTFX", "clear_text": "YOU ENGLISH WILL EVER BE THE SAME", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 7, "rotation": 19, "source_dataset": "caesar_cipher", "source_index": 40}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 720 degrees clockwise:
5 9 1 0 4 8
9 5 4 2 5 2
2 1 6 5 2 6
9 6 7 7 3 2
9 4 8 4 0 5
9 1 5 2 6 8
|
5 9 1 0 4 8
9 5 4 2 5 2
2 1 6 5 2 6
9 6 7 7 3 2
9 4 8 4 0 5
9 1 5 2 6 8
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[5, 9, 1, 0, 4, 8], [9, 5, 4, 2, 5, 2], [2, 1, 6, 5, 2, 6], [9, 6, 7, 7, 3, 2], [9, 4, 8, 4, 0, 5], [9, 1, 5, 2, 6, 8]], "n": 6, "num_rotations": 8, "solution": [[5, 9, 1, 0, 4, 8], [9, 5, 4, 2, 5, 2], [2, 1, 6, 5, 2, 6], [9, 6, 7, 7, 3, 2], [9, 4, 8, 4, 0, 5], [9, 1, 5, 2, 6, 8]], "source_dataset": "rotate_matrix", "source_index": 27}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:7, B:5, C:7
And your target is: 1 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill B", "pour B->A", "fill B", "pour B->A", "pour B->C", "pour A->B", "pour B->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [7, 5, 7], "min_moves": 7, "target": 1}, "source_dataset": "jugs", "source_index": 74}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 900 degrees clockwise:
8 8 2 7 0 2
0 9 1 4 3 0
9 8 9 3 1 5
4 6 5 2 2 2
6 5 9 2 9 6
9 4 8 2 1 1
|
1 1 2 8 4 9
6 9 2 9 5 6
2 2 2 5 6 4
5 1 3 9 8 9
0 3 4 1 9 0
2 0 7 2 8 8
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[8, 8, 2, 7, 0, 2], [0, 9, 1, 4, 3, 0], [9, 8, 9, 3, 1, 5], [4, 6, 5, 2, 2, 2], [6, 5, 9, 2, 9, 6], [9, 4, 8, 2, 1, 1]], "n": 6, "num_rotations": 10, "solution": [[1, 1, 2, 8, 4, 9], [6, 9, 2, 9, 5, 6], [2, 2, 2, 5, 6, 4], [5, 1, 3, 9, 8, 9], [0, 3, 4, 1, 9, 0], [2, 0, 7, 2, 8, 8]], "source_dataset": "rotate_matrix", "source_index": 17}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
pp hg
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 13, "string_length": 2, "words": ["pp", "hg"]}
|
Solve this cryptarithm:
SIZN
+ MMSXO
-------
MBMYN
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
B=9,I=7,M=3,N=6,O=0,S=5,X=4,Y=2,Z=8
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "O", "2": "Y", "3": "M", "4": "X", "5": "S", "6": "N", "7": "I", "8": "Z", "9": "B"}, "letter_to_digit": {"B": 9, "I": 7, "M": 3, "N": 6, "O": 0, "S": 5, "X": 4, "Y": 2, "Z": 8}, "letters": ["I", "N", "B", "Z", "X", "O", "Y", "S", "M"], "result_letters": "MBMYN", "source_dataset": "cryptarithm", "source_index": 7, "sum_number": 39326, "word_values": [5786, 33540], "words_letters": ["SIZN", "MMSXO"]}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
A# #A A# #B #A A# A# #B #A #A
Return the final state of the program.
|
#B #B
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 53}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 1 1 1
1 1 1 1
1 1 0 0
1 0 1 0
|
4 3 2 2
3 2 1 1
2 1 0 0
1 0 1 0
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 0, 0], [1, 0, 1, 0]], "n": 4, "solution": [[4, 3, 2, 2], [3, 2, 1, 1], [2, 1, 0, 0], [1, 0, 1, 0]], "source_dataset": "binary_matrix", "source_index": 7}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
cjcbs pmcer
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 72, "string_length": 5, "words": ["cjcbs", "pmcer"]}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:3, B:8, C:8
And your target is: 4 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill A", "pour A->B", "fill A", "pour A->B", "fill A", "pour A->B", "pour A->C", "fill A", "pour A->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [3, 8, 8], "min_moves": 9, "target": 4}, "source_dataset": "jugs", "source_index": 63}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 270 degrees clockwise:
8 5
6 2
|
5 2
8 6
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[8, 5], [6, 2]], "n": 2, "num_rotations": 3, "solution": [[5, 2], [8, 6]], "source_dataset": "rotate_matrix", "source_index": 90}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string suffix is 'cc', replace it with 'b' and prepend 'a' to the start.
2. If the string starts with 'bb', remove the second character.
3. If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.
4. If the string contains 'acb', replace the first occurrence with its reverse ('bca').
5. If the string prefix is 'aa', remove the first character.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
abaaabacaab
|
abaaabacaab
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 5, "selected_rules": ["If the string suffix is 'cc', replace it with 'b' and prepend 'a' to the start.", "If the string starts with 'bb', remove the second character.", "If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.", "If the string contains 'acb', replace the first occurrence with its reverse ('bca').", "If the string prefix is 'aa', remove the first character."], "solution": "abaaabacaab", "source_dataset": "string_manipulation", "source_index": 53, "states": ["abaaabacaab"], "string": "abaaabacaab", "string_length": 11}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 1 1
1 0 1
0 1 0
|
2 1 2
1 0 1
0 1 0
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 1, 1], [1, 0, 1], [0, 1, 0]], "n": 3, "solution": [[2, 1, 2], [1, 0, 1], [0, 1, 0]], "source_dataset": "binary_matrix", "source_index": 94}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 0011110010101010
|
2
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 16, "solution": 2, "solvable": true, "source_dataset": "binary_alternation", "source_index": 66, "string": "0011110010101010"}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string length is greater than 15, remove the middle character.
2. If the string contains 'ca' (not at the start), remove the first occurrence found after the first character.
3. If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.
4. If the string prefix is 'aa', remove the first character.
5. If the string starts with 'bb', remove the second character.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
abbcaaacb
|
abbaacb
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 5, "selected_rules": ["If the string length is greater than 15, remove the middle character.", "If the string contains 'ca' (not at the start), remove the first occurrence found after the first character.", "If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.", "If the string prefix is 'aa', remove the first character.", "If the string starts with 'bb', remove the second character."], "solution": "abbaacb", "source_dataset": "string_manipulation", "source_index": 30, "states": ["abbcaaacb", "abbaacb"], "string": "abbcaaacb", "string_length": 9}
|
Solve this cryptarithm:
NJJQF
+ ZUX
-------
NJQNL
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
F=9,J=0,L=1,N=4,Q=8,U=5,X=2,Z=7
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "J", "1": "L", "2": "X", "4": "N", "5": "U", "7": "Z", "8": "Q", "9": "F"}, "letter_to_digit": {"F": 9, "J": 0, "L": 1, "N": 4, "Q": 8, "U": 5, "X": 2, "Z": 7}, "letters": ["L", "Q", "X", "U", "N", "Z", "J", "F"], "result_letters": "NJQNL", "source_dataset": "cryptarithm", "source_index": 86, "sum_number": 40841, "word_values": [40089, 752], "words_letters": ["NJJQF", "ZUX"]}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
0 0 1 0 1
1 1 0 0 0
1 1 0 1 0
1 1 0 1 1
1 1 1 1 1
|
0 0 1 0 1
1 1 0 0 0
2 1 0 1 0
2 1 0 1 1
3 2 1 2 2
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[0, 0, 1, 0, 1], [1, 1, 0, 0, 0], [1, 1, 0, 1, 0], [1, 1, 0, 1, 1], [1, 1, 1, 1, 1]], "n": 5, "solution": [[0, 0, 1, 0, 1], [1, 1, 0, 0, 0], [2, 1, 0, 1, 0], [2, 1, 0, 1, 1], [3, 2, 1, 2, 2]], "source_dataset": "binary_matrix", "source_index": 26}
|
A::B is a system with 4 tokens: `A#`, `#A`, `B#` and `#B`.
An A::B program is a sequence of tokens. Example:
B# A# #B #A B#
To *compute* a program, we must rewrite neighbor tokens, using the rules:
A# #A ... becomes ... nothing
A# #B ... becomes ... #B A#
B# #A ... becomes ... #A B#
B# #B ... becomes ... nothing
In other words, whenever two neighbor tokens have their '#' facing each-other,
they must be rewritten according to the corresponding rule.
Now, consider the following program:
A# #A A# A# #A #B A# A# #B #B
Return the final state of the program.
|
#B #B #B A# A# A#
|
ab
|
{"difficulty": {"length": 10}, "source_dataset": "ab", "source_index": 16}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string starts with 'cc', remove the first two characters.
2. If the string prefix is 'ab', replace it with 'ca'.
3. If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.
4. If the string starts with 'bb', remove the second character.
5. If the string ends with 'aa', replace it with 'cc'.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
bbacacaa
|
bacaccc
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 5, "selected_rules": ["If the string starts with 'cc', remove the first two characters.", "If the string prefix is 'ab', replace it with 'ca'.", "If the string prefix is 'bc', delete the first two characters and append 'aa' to the end.", "If the string starts with 'bb', remove the second character.", "If the string ends with 'aa', replace it with 'cc'."], "solution": "bacaccc", "source_dataset": "string_manipulation", "source_index": 18, "states": ["bbacacaa", "bacacaa", "bacaccc"], "string": "bbacacaa", "string_length": 8}
|
Given a square matrix, your job is to rotate it clockwise.
Your output should be a matrix in the same format as the input.
Rotate the matrix below by 630 degrees clockwise:
7 1 2 6 0
0 3 3 2 4
1 0 6 2 5
4 8 3 7 3
7 2 0 0 0
|
0 4 5 3 0
6 2 2 7 0
2 3 6 3 0
1 3 0 8 2
7 0 1 4 7
|
rotate_matrix
|
{"difficulty": {"n": [2, 6], "num_rotations": [0, 10]}, "matrix": [[7, 1, 2, 6, 0], [0, 3, 3, 2, 4], [1, 0, 6, 2, 5], [4, 8, 3, 7, 3], [7, 2, 0, 0, 0]], "n": 5, "num_rotations": 7, "solution": [[0, 4, 5, 3, 0], [6, 2, 2, 7, 0], [2, 3, 6, 3, 0], [1, 3, 0, 8, 2], [7, 0, 1, 4, 7]], "source_dataset": "rotate_matrix", "source_index": 5}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
0 0 1 1 1
0 0 1 1 0
1 1 1 1 0
1 1 1 0 1
1 1 0 1 0
|
0 0 1 2 1
0 0 1 1 0
1 1 2 1 0
2 2 1 0 1
2 1 0 1 0
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[0, 0, 1, 1, 1], [0, 0, 1, 1, 0], [1, 1, 1, 1, 0], [1, 1, 1, 0, 1], [1, 1, 0, 1, 0]], "n": 5, "solution": [[0, 0, 1, 2, 1], [0, 0, 1, 1, 0], [1, 1, 2, 1, 0], [2, 2, 1, 0, 1], [2, 1, 0, 1, 0]], "source_dataset": "binary_matrix", "source_index": 15}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-4 number 12212 to base-8
|
646
|
base_conversion
|
{"decimal_value": 422, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 4, "source_dataset": "base_conversion", "source_index": 61, "source_repr": "12212", "target_base": 8, "target_repr": "646"}
|
Decrypt this Caesar cipher text: JVGUBHG ZNAVSRFGVAT GUR FYVTUGRFG VEEVGNGVBA. Provide only the decrypted text as your final answer.
|
WITHOUT MANIFESTING THE SLIGHTEST IRRITATION
|
caesar_cipher
|
{"cipher_text": "JVGUBHG ZNAVSRFGVAT GUR FYVTUGRFG VEEVGNGVBA", "clear_text": "WITHOUT MANIFESTING THE SLIGHTEST IRRITATION", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 5, "rotation": 13, "source_dataset": "caesar_cipher", "source_index": 54}
|
Your task is to convert a number between two different bases.
If the target base is > 10, use lowercase letters a-z for digits above 9.
Now, convert the base-8 number 1674 to base-14
|
4c4
|
base_conversion
|
{"decimal_value": 956, "difficulty": {"base": [2, 16], "value": [0, 1000]}, "source_base": 8, "source_dataset": "base_conversion", "source_index": 39, "source_repr": "1674", "target_base": 14, "target_repr": "4c4"}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 0 1 1
1 1 1 1
1 1 1 1
0 1 1 0
|
1 0 1 2
2 1 2 2
1 2 2 1
0 1 1 0
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 0, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [0, 1, 1, 0]], "n": 4, "solution": [[1, 0, 1, 2], [2, 1, 2, 2], [1, 2, 2, 1], [0, 1, 1, 0]], "source_dataset": "binary_matrix", "source_index": 25}
|
Given a binary string, return the minimum number of character swaps to make it alternating, or -1 if it is impossible.
The string is called alternating if no two adjacent characters are equal. For example, the strings "010" and "1010" are alternating, while the string "0100" is not.
Any two characters may be swapped, even if they are not adjacent.
Now, determine the minimum number of swaps to make the following binary string alternating: 0101010110101100
|
3
|
binary_alternation
|
{"difficulty": {"n": [10, 30]}, "n": 16, "solution": 3, "solvable": true, "source_dataset": "binary_alternation", "source_index": 6, "string": "0101010110101100"}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 0 1 1 1
0 0 1 1 1
1 1 1 1 0
1 1 1 0 0
1 1 1 1 1
|
1 0 1 2 2
0 0 1 2 1
1 1 2 1 0
2 2 1 0 0
3 3 2 1 1
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 0, 1, 1, 1], [0, 0, 1, 1, 1], [1, 1, 1, 1, 0], [1, 1, 1, 0, 0], [1, 1, 1, 1, 1]], "n": 5, "solution": [[1, 0, 1, 2, 2], [0, 0, 1, 2, 1], [1, 1, 2, 1, 0], [2, 2, 1, 0, 0], [3, 3, 2, 1, 1]], "source_dataset": "binary_matrix", "source_index": 60}
|
Two strings are isomorphic if the characters in one string can be replaced to get the second string.
All occurrences of a character must be replaced with another character while preserving the order of characters.
No two characters may map to the same character, but a character may map to itself.
Return True if the following two strings are isomorphic, or False otherwise:
vqq ffz
|
False
|
isomorphic_strings
|
{"difficulty": {"string_length": [2, 8]}, "solution": false, "solvable": false, "source_dataset": "isomorphic_strings", "source_index": 14, "string_length": 3, "words": ["vqq", "ffz"]}
|
Decrypt this Caesar cipher text: KLOQE CLO QEB LC YRQ QEB PLRQE CLO QEB IXQFKP. Provide only the decrypted text as your final answer.
|
NORTH FOR THE OF BUT THE SOUTH FOR THE LATINS
|
caesar_cipher
|
{"cipher_text": "KLOQE CLO QEB LC YRQ QEB PLRQE CLO QEB IXQFKP", "clear_text": "NORTH FOR THE OF BUT THE SOUTH FOR THE LATINS", "difficulty": {"rotation": [1, 25], "words": [3, 10]}, "num_words": 10, "rotation": 23, "source_dataset": "caesar_cipher", "source_index": 16}
|
You are a police officer. A maniac has planted a bomb next to a public fountain.
To defuse the bomb, you must solve a puzzle. The puzzle is solved when you fill any of the available jugs with the target amount of water.
You have three move types: 'fill', 'empty' and 'pour'.
To fill Jug A, you 'fill A'.
To empty Jug B, you 'empty B'.
To pour the contents of Jug A into Jug B, you 'pour A->B'.
All jugs are empty to begin with.
The empty jugs hold this many litres of water: A:8, B:8, C:9
And your target is: 5 litres.
How do you defuse the bomb?
Reply as a JSON-parsable list of moves which result in any of the jugs being filled with the target amount.
|
["fill A", "pour A->C", "fill A", "pour A->C", "fill B", "empty C", "pour A->C", "fill A", "pour A->C", "empty C", "pour A->C", "pour B->C"]
|
jugs
|
{"difficulty": {"difficulty": 6, "num_jugs": 3}, "puzzle": {"jug_capacities": [8, 8, 9], "min_moves": 12, "target": 5}, "source_dataset": "jugs", "source_index": 1}
|
Your job is to repeatedly transform a string according to a set of rules until no further transformations can be performed, or a state is repeated.
Evaluate the following rules in order, and apply the first applicable rule to the string:
1. If the string ends with 'ba', replace it with 'ab'.
2. If the string contains 'bca', delete the first occurrence entirely.
3. If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.
4. If the string ends with 'ca', remove the last character.
Once you have applied a rule, repeat the process with the new string until no further transformations can be performed (i.e. the string doesn't change), or a state is repeated.
If a state is repeated, the process is terminated, and the repeated state is discarded (i.e. is not considered as the final answer) and the state before the repeated state is considered as the final answer.
Your output should be the final transformed string after applying all the rules.
Transform the following string according to the above list of rules:
acbcac
|
acc
|
string_manipulation
|
{"difficulty": {"num_rules": [3, 6], "string_length": [5, 15]}, "num_rules": 4, "selected_rules": ["If the string ends with 'ba', replace it with 'ab'.", "If the string contains 'bca', delete the first occurrence entirely.", "If the string prefix is 'ca', replace it with 'bb' and append 'c' to the end.", "If the string ends with 'ca', remove the last character."], "solution": "acc", "source_dataset": "string_manipulation", "source_index": 42, "states": ["acbcac", "acc"], "string": "acbcac", "string_length": 6}
|
Given a square matrix, your job is to find the taxicab (Manhattan) distance of the nearest 0 for each cell.
The output should be a matrix of the same size as the input matrix, where each cell contains the distance to the nearest 0.
Find the distance to the nearest 0 for each cell in the matrix below:
1 0 1 1 1 0
1 1 1 1 1 1
0 0 1 1 1 0
1 0 1 0 1 0
1 1 1 1 0 1
1 1 1 1 0 1
|
1 0 1 2 1 0
1 1 2 2 2 1
0 0 1 1 1 0
1 0 1 0 1 0
2 1 2 1 0 1
3 2 2 1 0 1
|
binary_matrix
|
{"difficulty": {"n": [2, 6], "p_zero": 0.25}, "matrix": [[1, 0, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 0], [1, 0, 1, 0, 1, 0], [1, 1, 1, 1, 0, 1], [1, 1, 1, 1, 0, 1]], "n": 6, "solution": [[1, 0, 1, 2, 1, 0], [1, 1, 2, 2, 2, 1], [0, 0, 1, 1, 1, 0], [1, 0, 1, 0, 1, 0], [2, 1, 2, 1, 0, 1], [3, 2, 2, 1, 0, 1]], "source_dataset": "binary_matrix", "source_index": 63}
|
Solve this cryptarithm:
XTUVI
CWCCT
+ TMWWC
--------
UYIXMI
Each letter stands for a unique digit (0-9). No leading letter can be zero.
Provide a comma separated mapping from letters to digits that satisfies the equation in your final answer. Output format: "A=1,B=2,C=3" (without quotes)
|
C=2,I=7,M=9,T=8,U=1,V=6,W=0,X=3,Y=4
|
cryptarithm
|
{"difficulty": {"words": [2, 3]}, "digit_to_letter": {"0": "W", "1": "U", "2": "C", "3": "X", "4": "Y", "6": "V", "7": "I", "8": "T", "9": "M"}, "letter_to_digit": {"C": 2, "I": 7, "M": 9, "T": 8, "U": 1, "V": 6, "W": 0, "X": 3, "Y": 4}, "letters": ["M", "V", "Y", "T", "W", "C", "X", "I", "U"], "result_letters": "UYIXMI", "source_dataset": "cryptarithm", "source_index": 28, "sum_number": 147397, "word_values": [38167, 20228, 89002], "words_letters": ["XTUVI", "CWCCT", "TMWWC"]}
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 10