task_id stringlengths 16 16 | entry_point stringclasses 1
value | prompt stringlengths 893 1.15k | canonical_solution stringlengths 113 230 | canonical_pipeline listlengths 1 5 | test stringlengths 1.68k 2.65k | num_tests int64 40 40 | examples listlengths 8 8 | tests listlengths 32 32 | metadata dict |
|---|---|---|---|---|---|---|---|---|---|
pbe-world/000000 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.lower()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('aa') == 'AA'
assert candidate('baaaaaaaba') == 'BAAAAAAABA'
assert candidate('aa') == 'AA'
assert candidate('aababbaab') == 'AABABBAAB'
a... | 40 | [
{
"input": "b",
"output": "B"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baaaaaaaba",
"output": "BAAAAAAABA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aababbaab",
"output": "AABABBAAB"
},
{
"input": "bbabbabab",
"output": "BBABBABAB"... | [
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaaabbb",
"output": "AAAABBB"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaababaabb",
"output": "AAABABAABB"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000001 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbaaba') == 'abbbaaba'
assert candidate('b') == 'b'
assert candidate('bbaba') == 'bbaba'
assert candidate('bbabbaba') == 'bbabbaba'
assert candidate('b') == 'b'
ass... | 40 | [
{
"input": "abbbaaba",
"output": "abbbaaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "bbabbaba",
"output": "bbabbaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "ababbbaa",
"output": "ababbbaa"
}... | [
{
"input": "aba",
"output": "aba"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "bbbbaaaa",
"output": "bbbbaaaa"
},
{
"input": "aaaaa",
"output": "aaaaa"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbaabbbaab",
"output": "bbaabbbaab"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000002 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaba') == 'bbaaba'
assert candidate('baab') == 'baab'
assert candidate('bbbb') == 'bbbb'
assert candidate('a') == 'a'
assert candidate('aabba') == 'aabba'
assert ca... | 40 | [
{
"input": "bbaaba",
"output": "bbaaba"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "bb",
"output": "bb"
},
{
"input":... | [
{
"input": "abbbbba",
"output": "abbbbba"
},
{
"input": "aaaababa",
"output": "aaaababa"
},
{
"input": "ababbbabb",
"output": "ababbbabb"
},
{
"input": "aaabaa",
"output": "aaabaa"
},
{
"input": "bababa",
"output": "bababa"
},
{
"input": "baabbbbaaa",
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000003 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('B', 'baaa')
s = s.replace('AAba', 'aa')
s = s.replace('aAa', 'aabb')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"B",
"baaa"
]
},
{
"method": "replace",
"args": [
"AAba",
"aa"
]
},
{
"method": "replace",
"args": [
"aAa",
"aabb... | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baaabaab') == 'baaaabbaaaaaaa'
assert candidate('bbbaa') == 'baaabaaabaaaAA'
assert candidate('aaabbababa') == 'AaaaabaaaAbaaaAbaaaA'
assert candidate('bbaabbbbb') == 'baaaba... | 40 | [
{
"input": "baaabaab",
"output": "baaaabbaaaaaaa"
},
{
"input": "bbbaa",
"output": "baaabaaabaaaAA"
},
{
"input": "aaabbababa",
"output": "AaaaabaaaAbaaaAbaaaA"
},
{
"input": "bbaabbbbb",
"output": "baaabaaaaaaabaaabaaabaaabaaa"
},
{
"input": "b",
"output": "b... | [
{
"input": "ba",
"output": "baaaA"
},
{
"input": "abbabbaa",
"output": "AbaaabaaaAbaaabaaaAA"
},
{
"input": "aaaaab",
"output": "AAAaaaa"
},
{
"input": "b",
"output": "baaa"
},
{
"input": "bbaaabbbb",
"output": "baaabaaaabbaaabaaabaaabaaa"
},
{
"input"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000004 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('babab', 'aab')
s = s.replace('ab', 'a')
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"babab",
"aab"
]
},
{
"method": "replace",
"args": [
"ab",
"a"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abb') == 'AB'
assert candidate('bababab') == 'AAA'
assert candidate('bbbbaabb') == 'BBBBAAB'
assert candidate('abba') == 'ABA'
assert candidate('aabbbbb') == 'AABBBB'
... | 40 | [
{
"input": "abb",
"output": "AB"
},
{
"input": "bababab",
"output": "AAA"
},
{
"input": "bbbbaabb",
"output": "BBBBAAB"
},
{
"input": "abba",
"output": "ABA"
},
{
"input": "aabbbbb",
"output": "AABBBB"
},
{
"input": "bbbabbaa",
"output": "BBBABAA"
... | [
{
"input": "baaaaba",
"output": "BAAAAA"
},
{
"input": "bbabaabbba",
"output": "BBAAABBA"
},
{
"input": "abbabbbbb",
"output": "ABABBBB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "baabababb",
"output": "BAAAAB"
},
{
"input": "ababababb",
"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000005 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('ABBB', 'bba')
s = s.replace('AAb', 'ba')
s = s.lower()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"ABBB",
"bba"
]
},
{
"method": "replace",
"args": [
"AAb",
"ba"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baaababb') == 'BAAABABB'
assert candidate('baabbba') == 'BABBAA'
assert candidate('bbbaa') == 'BBBAA'
assert candidate('aa') == 'AA'
assert candidate('abbbab') == 'BBAAB'... | 40 | [
{
"input": "baaababb",
"output": "BAAABABB"
},
{
"input": "baabbba",
"output": "BABBAA"
},
{
"input": "bbbaa",
"output": "BBBAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "abbbab",
"output": "BBAAB"
},
{
"input": "ababb",
"output": "ABABB"
... | [
{
"input": "bbbbaaa",
"output": "BBBBAAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "babbaabba",
"output": "BABBAABBA"
},
{
"input": "abaababb",
"output": "ABAABABB"
},
{
"input": "abaaab",
"output": "ABAAAB"
},
{
"input": "baaaaabbab",
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000006 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbab') == 'bbab'
assert candidate('abbb') == 'abbb'
assert candidate('bbaaaa') == 'bbaaaa'
assert candidate('aaa') == 'aaa'
assert candidate('ababaaaaaa') == 'ababaaaaaa'... | 40 | [
{
"input": "bbab",
"output": "bbab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "bbaaaa",
"output": "bbaaaa"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "ababaaaaaa",
"output": "ababaaaaaa"
},
{
"input": "babb",
"output": "babb"
}... | [
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "babaa",
"output": "babaa"
},
{
"input": "abbbbbbbb",
"output": "abbbbbbbb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"inp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000007 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bb', 'bbaab')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"bb",
"bbaab"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bab') == 'BAB'
assert candidate('abbabaaaba') == 'ABBAABABAAABA'
assert candidate('a') == 'A'
assert candidate('bbbb') == 'BBAABBBAAB'
assert candidate('aaaabbaaba') == '... | 40 | [
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbabaaaba",
"output": "ABBAABABAAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbb",
"output": "BBAABBBAAB"
},
{
"input": "aaaabbaaba",
"output": "AAAABBAABAABA"
},
{
"input": "b",
"output":... | [
{
"input": "ab",
"output": "AB"
},
{
"input": "bbbb",
"output": "BBAABBBAAB"
},
{
"input": "bbaba",
"output": "BBAABABA"
},
{
"input": "abaabbbaaa",
"output": "ABAABBAABBAAA"
},
{
"input": "bbba",
"output": "BBAABBA"
},
{
"input": "aabbab",
"output... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000008 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbab', 'aab')
s = s.upper()
s = s.upper()
s = s.upper()
s = s.lower()
return s
| [
{
"method": "replace",
"args": [
"bbab",
"aab"
]
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaa') == 'bbaa'
assert candidate('bbbbaa') == 'bbbbaa'
assert candidate('aabbaba') == 'aaaaba'
assert candidate('baba') == 'baba'
assert candidate('abababbbba') == 'abab... | 40 | [
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "aabbaba",
"output": "aaaaba"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "abababbbba",
"output": "abababbbba"
},
{
"input": "abbbaaa",
"output": ... | [
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "aaaabaaba",
"output": "aaaabaaba"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"i... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000009 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baaabaaab') == 'baaabaaab'
assert candidate('aab') == 'aab'
assert candidate('abbbbb') == 'abbbbb'
assert candidate('aabaaaabbb') == 'aabaaaabbb'
assert candidate('baabba... | 40 | [
{
"input": "baaabaaab",
"output": "baaabaaab"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "abbbbb",
"output": "abbbbb"
},
{
"input": "aabaaaabbb",
"output": "aabaaaabbb"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "bba",
"output... | [
{
"input": "abbaaaba",
"output": "abbaaaba"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "bbabbabb",
"output": "bbabbabb"
},
{
"input": "bbbaaa",
"output": "bbbaaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbaaabaab",
"output":... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000010 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaaab', 'aaabb')
s = s.lower()
s = s.lower()
s = s.upper()
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"aaaab",
"aaabb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ababbb') == 'ABABBB'
assert candidate('ba') == 'BA'
assert candidate('baaab') == 'BAAAB'
assert candidate('aabbbbbbaa') == 'AABBBBBBAA'
assert candidate('aabab') == 'AABA... | 40 | [
{
"input": "ababbb",
"output": "ABABBB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "aabbbbbbaa",
"output": "AABBBBBBAA"
},
{
"input": "aabab",
"output": "AABAB"
},
{
"input": "b",
"output": "B"
},
... | [
{
"input": "abababa",
"output": "ABABABA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "aabbbaabab",
"output": "AABBBAABAB"
},
{
"input": "abbabbaaba",
"output": "ABBABBAABA"
},
{
"input": "baaaabbb",
"output": "BAAABBBB"
},
{
"input": "aabbbbabb... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000011 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('b', 'bbaab')
s = s.lower()
s = s.upper()
s = s.upper()
s = s.replace('AAABB', 'baabb')
return s
| [
{
"method": "replace",
"args": [
"b",
"bbaab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AAABB",
"baabb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babba') == 'BBAABABBAABBBAABA'
assert candidate('aaaaab') == 'AAbaabbAAB'
assert candidate('abbba') == 'ABBAABBBAABBBAABA'
assert candidate('aaabaa') == 'baabbAABAA'
asse... | 40 | [
{
"input": "babba",
"output": "BBAABABBAABBBAABA"
},
{
"input": "aaaaab",
"output": "AAbaabbAAB"
},
{
"input": "abbba",
"output": "ABBAABBBAABBBAABA"
},
{
"input": "aaabaa",
"output": "baabbAABAA"
},
{
"input": "b",
"output": "BBAAB"
},
{
"input": "abb... | [
{
"input": "aa",
"output": "AA"
},
{
"input": "b",
"output": "BBAAB"
},
{
"input": "aabaabb",
"output": "AABBAABAABBAABBBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bababaabb",
"output": "BBAABABBAABABBAABAABBAABBBAAB"
},
{
"input": "bbabaabaa... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000012 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aba', 'baaba')
return s
| [
{
"method": "replace",
"args": [
"aba",
"baaba"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bb') == 'bb'
assert candidate('aababaaa') == 'abaababaaa'
assert candidate('aaabb') == 'aaabb'
assert candidate('bbabaaba') == 'bbbaababaaba'
assert candidate('ab') == 'a... | 40 | [
{
"input": "bb",
"output": "bb"
},
{
"input": "aababaaa",
"output": "abaababaaa"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "bbabaaba",
"output": "bbbaababaaba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "babba",
"output": "babba"... | [
{
"input": "abaaa",
"output": "baabaaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaaba",
"output": "bbabaaba"
},
{
"input": "a",
"output": "a"
},
{
"input": "aababa",
"output": "abaababa"
},
{
"i... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000013 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababaaa') == 'AABABAAA'
assert candidate('b') == 'B'
assert candidate('bbb') == 'BBB'
assert candidate('abbbaaabba') == 'ABBBAAABBA'
assert candidate('abbaaaabaa') == 'A... | 40 | [
{
"input": "aababaaa",
"output": "AABABAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "abbbaaabba",
"output": "ABBBAAABBA"
},
{
"input": "abbaaaabaa",
"output": "ABBAAAABAA"
},
{
"input": "a",
"output": "A"... | [
{
"input": "babab",
"output": "BABAB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "bbbbbabaa",
"output": "BBBBBABAA"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000014 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baaba') == 'baaba'
assert candidate('bb') == 'bb'
assert candidate('aaaa') == 'aaaa'
assert candidate('babbbba') == 'babbbba'
assert candidate('baaaa') == 'baaaa'
ass... | 40 | [
{
"input": "baaba",
"output": "baaba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "babbbba",
"output": "babbbba"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "b",
"output": "b"
},
{
"inp... | [
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbab",
"output": "bbbab"
},
{
"input": "babbbabab",
"output": "babbbabab"
},
{
"input": "bbaaaabb",
"output": "bbaaaabb"
},
{
"input": "baabb",
"output": "baabb"
},
{
"input": "b",
"output": "b"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000015 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ba') == 'ba'
assert candidate('b') == 'b'
assert candidate('aaabaababa') == 'aaabaababa'
assert candidate('bbbbbab') == 'bbbbbab'
assert candidate('baabbaa') == 'baabbaa'... | 40 | [
{
"input": "ba",
"output": "ba"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaabaababa",
"output": "aaabaababa"
},
{
"input": "bbbbbab",
"output": "bbbbbab"
},
{
"input": "baabbaa",
"output": "baabbaa"
},
{
"input": "bbbbabba",
"output": "bbbba... | [
{
"input": "babaabbbba",
"output": "babaabbbba"
},
{
"input": "bbbaaabb",
"output": "bbbaaabb"
},
{
"input": "abbbabbbb",
"output": "abbbabbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "abbabbbbb",
"ou... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000016 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaabb', 'abbb')
s = s.replace('abaa', 'bb')
return s
| [
{
"method": "replace",
"args": [
"aaabb",
"abbb"
]
},
{
"method": "replace",
"args": [
"abaa",
"bb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbababbba') == 'abbababbba'
assert candidate('bab') == 'bab'
assert candidate('babbaabaab') == 'babbabbb'
assert candidate('bb') == 'bb'
assert candidate('bb') == 'bb'
... | 40 | [
{
"input": "abbababbba",
"output": "abbababbba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "babbaabaab",
"output": "babbabbb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "b",
"output": "b"
},
{
... | [
{
"input": "bbaaabbaba",
"output": "bbabbbaba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaababba",
"output": "aaababba"
},
{
"input": "aaaaaabab",
"output": "aaa... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000017 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BBABB', 'abaa')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BBABB",
"abaa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baab') == 'BAAB'
assert candidate('aaabbbaab') == 'AAABBBAAB'
assert candidate('aabbabaaa') == 'AABBABAAA'
assert candidate('ababbbbbab') == 'ABABBBBBAB'
assert candidate... | 40 | [
{
"input": "baab",
"output": "BAAB"
},
{
"input": "aaabbbaab",
"output": "AAABBBAAB"
},
{
"input": "aabbabaaa",
"output": "AABBABAAA"
},
{
"input": "ababbbbbab",
"output": "ABABBBBBAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaabb",
"outpu... | [
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbbbaabbb",
"output": "ABBBBAABBB"
},
{
"input": "babaa",
"output": "BABAA"
},
{
"input": "bbbaabaaab",
"output": "BBBAABAAAB"
},
{
"input": "baabbabaa",
"output": "BAABBABAA"
},
{
"input": "bbbabaaba",... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000018 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aba', 'bb')
return s
| [
{
"method": "replace",
"args": [
"aba",
"bb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babbbbaab') == 'babbbbaab'
assert candidate('abbbbbbbb') == 'abbbbbbbb'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('bbbaabaaa') == 'bbbabb... | 40 | [
{
"input": "babbbbaab",
"output": "babbbbaab"
},
{
"input": "abbbbbbbb",
"output": "abbbbbbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbaabaaa",
"output": "bbbabbaa"
},
{
"input": "aaa",
"output": "aaa"
... | [
{
"input": "aab",
"output": "aab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabba",
"output": "bbabba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "baababaaa",
"output": "babbbaaa"
},
{
"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000019 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BAB', 'ab')
s = s.replace('Aab', 'bbab')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAB",
"ab"
]
},
{
"method": "replace",
"args": [
"Aab",
"bbab"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbaa') == 'BBBAA'
assert candidate('bababaab') == 'ABABAAB'
assert candidate('ba') == 'BA'
assert candidate('bbaaba') == 'BBAABA'
assert candidate('aaaaaa') == 'AAAAAA'
... | 40 | [
{
"input": "bbbaa",
"output": "BBBAA"
},
{
"input": "bababaab",
"output": "ABABAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbaaba",
"output": "BBAABA"
},
{
"input": "aaaaaa",
"output": "AAAAAA"
},
{
"input": "bbaaabbabb",
"output": "BBAA... | [
{
"input": "ababa",
"output": "BBABA"
},
{
"input": "aaaaaabab",
"output": "AAAAABBAB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "bababbbbb",
"output": "ABAB... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000020 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.upper()
s = s.upper()
s = s.replace('ABAA', 'bab')
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"ABAA",
"bab"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbabb') == 'ABBBABB'
assert candidate('bbb') == 'BBB'
assert candidate('aaabaa') == 'AAbab'
assert candidate('aaabba') == 'AAABBA'
assert candidate('aab') == 'AAB'
... | 40 | [
{
"input": "abbbabb",
"output": "ABBBABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aaabaa",
"output": "AAbab"
},
{
"input": "aaabba",
"output": "AAABBA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbbabaaa",
"output": "BBBbabA"
... | [
{
"input": "ab",
"output": "AB"
},
{
"input": "baabaaaaab",
"output": "BAbabAAAB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababbb",
"output": "ABABBB"
},
{
"in... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000021 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'ab')
s = s.replace('bbba', 'bbaaa')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"a",
"ab"
]
},
{
"method": "replace",
"args": [
"bbba",
"bbaaa"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbabaa') == 'ABBAAABBABAB'
assert candidate('abaaaabaa') == 'ABBABABABABBABAB'
assert candidate('a') == 'AB'
assert candidate('baba') == 'BABBAB'
assert candidate('baba'... | 40 | [
{
"input": "abbabaa",
"output": "ABBAAABBABAB"
},
{
"input": "abaaaabaa",
"output": "ABBABABABABBABAB"
},
{
"input": "a",
"output": "AB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "aabaaaab",
"ou... | [
{
"input": "abbbbaaabb",
"output": "ABBBBAAABABABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aababba",
"output": "ABABBABBAAAB"
},
{
"input": "abaabbabaa",
"output": "ABBABABBAAABBABAB"
},
{
"input": "aababb",
"output": "ABABBABBB"
},
{
"input"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000022 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('A', 'baaab')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"A",
"baaab"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ab') == 'baaabB'
assert candidate('babba') == 'BbaaabBBbaaab'
assert candidate('bbbbba') == 'BBBBBbaaab'
assert candidate('bab') == 'BbaaabB'
assert candidate('b') == 'B'... | 40 | [
{
"input": "ab",
"output": "baaabB"
},
{
"input": "babba",
"output": "BbaaabBBbaaab"
},
{
"input": "bbbbba",
"output": "BBBBBbaaab"
},
{
"input": "bab",
"output": "BbaaabB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaaab",
"output": "BBbaaab... | [
{
"input": "a",
"output": "baaab"
},
{
"input": "aaaaababba",
"output": "baaabbaaabbaaabbaaabbaaabBbaaabBBbaaab"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabbabaa",
"output": "baaabbaaabBBbaaabBbaaabbaaab"
},
{
"input": "aaa",
"output": "baaabbaaabbaa... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000023 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaaba', 'baaab')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"aaaba",
"baaab"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaabbbba') == 'BBAABBBBA'
assert candidate('bababbabb') == 'BABABBABB'
assert candidate('bbb') == 'BBB'
assert candidate('aabbb') == 'AABBB'
assert candidate('baaabab') ... | 40 | [
{
"input": "bbaabbbba",
"output": "BBAABBBBA"
},
{
"input": "bababbabb",
"output": "BABABBABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "baaabab",
"output": "BBAAABB"
},
{
"input": "babbbbaabb",
"o... | [
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "aababaaaab",
"output": "AABABAAAAB"
},
{
"input": "babaabaaa",
"output": "BABAABAAA"
},
{
"input": "baabbbbaba",
"output": "BAABBBBABA"
},
{
"input": "ababba",
"output": "ABABBA"
},
{
"input": "bbb... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000024 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'a'
assert candidate('bbbbaabbbb') == 'bbbbaabbbb'
assert candidate('bbaabbaaa') == 'bbaabbaaa'
assert candidate('bbbbbb') == 'bbbbbb'
assert candidate('aabbab') =... | 40 | [
{
"input": "a",
"output": "a"
},
{
"input": "bbbbaabbbb",
"output": "bbbbaabbbb"
},
{
"input": "bbaabbaaa",
"output": "bbaabbaaa"
},
{
"input": "bbbbbb",
"output": "bbbbbb"
},
{
"input": "aabbab",
"output": "aabbab"
},
{
"input": "b",
"output": "b"... | [
{
"input": "bbbabaaba",
"output": "bbbabaaba"
},
{
"input": "baabaa",
"output": "baabaa"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aababaabbb",
"output": "aababaabbb"
},
{
"input": "bbbbaaaaab",
"out... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000025 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.replace('bbaaa', 'babb')
s = s.lower()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bbaaa",
"babb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababab') == 'aababab'
assert candidate('ababbbb') == 'ababbbb'
assert candidate('aaaab') == 'aaaab'
assert candidate('abb') == 'abb'
assert candidate('bbaababa') == 'bba... | 40 | [
{
"input": "aababab",
"output": "aababab"
},
{
"input": "ababbbb",
"output": "ababbbb"
},
{
"input": "aaaab",
"output": "aaaab"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbaababa",
"output": "bbaababa"
},
{
"input": "bbab",
"output": "bba... | [
{
"input": "aa",
"output": "aa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "babaab",
"output": "babaab"
},
{
"input": "aaabab",
"output": "aaabab"
},
{
"input": "bbaab",
"output": "bbaab"
},
{
"input": "ba",
"output": "ba"
},
{
"inp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000026 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('ABABA', 'ab')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"ABABA",
"ab"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababa') == 'AAB'
assert candidate('ba') == 'BA'
assert candidate('b') == 'B'
assert candidate('aabbaaaa') == 'AABBAAAA'
assert candidate('aaabaabbbb') == 'AAABAABBBB'
... | 40 | [
{
"input": "aababa",
"output": "AAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabbaaaa",
"output": "AABBAAAA"
},
{
"input": "aaabaabbbb",
"output": "AAABAABBBB"
},
{
"input": "aabaabaaa",
"output": "AABAABA... | [
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "abbbaaab",
"output": "ABBBAAAB"
},
{
"input": "baabba",
"output": "BAABBA"
},
{
"input": "bbabbaaa",
"output": "BBABBAAA"
},
{
"input": "bbbaaba",
"output": "BBBAABA"
},
{
"input": "babbbbaaaa",
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000027 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ab') == 'AB'
assert candidate('abba') == 'ABBA'
assert candidate('babbabbbaa') == 'BABBABBBAA'
assert candidate('aababbaaba') == 'AABABBAABA'
assert candidate('aaba') == ... | 40 | [
{
"input": "ab",
"output": "AB"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "babbabbbaa",
"output": "BABBABBBAA"
},
{
"input": "aababbaaba",
"output": "AABABBAABA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "baab",
"output": "BAA... | [
{
"input": "abbaab",
"output": "ABBAAB"
},
{
"input": "bababb",
"output": "BABABB"
},
{
"input": "bbbaab",
"output": "BBBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "aaaabbabbb",
"output": "AAAABBABBB"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000028 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbbbab') == 'ABBBBBAB'
assert candidate('abbb') == 'ABBB'
assert candidate('aaaaaaba') == 'AAAAAABA'
assert candidate('aaabba') == 'AAABBA'
assert candidate('aa') == 'A... | 40 | [
{
"input": "abbbbbab",
"output": "ABBBBBAB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "aaaaaaba",
"output": "AAAAAABA"
},
{
"input": "aaabba",
"output": "AAABBA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baabba",
"output": "BAABB... | [
{
"input": "abbbbbab",
"output": "ABBBBBAB"
},
{
"input": "baababbab",
"output": "BAABABBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "ababbbb",
"output": "ABABBBB"
},
{
"input": "bbbbbbba",
"output": ... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000029 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('AB', 'bba')
s = s.replace('ba', 'abaab')
s = s.lower()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AB",
"bba"
]
},
{
"method": "replace",
"args": [
"ba",
"abaab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbbbaab') == 'BBBBBABABAAB'
assert candidate('aaaaabaabb') == 'AAAABABAABABABAABB'
assert candidate('bababaab') == 'BBABAABBABAABABABAAB'
assert candidate('b') == 'B'
as... | 40 | [
{
"input": "bbbbbaab",
"output": "BBBBBABABAAB"
},
{
"input": "aaaaabaabb",
"output": "AAAABABAABABABAABB"
},
{
"input": "bababaab",
"output": "BBABAABBABAABABABAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "a... | [
{
"input": "aabaa",
"output": "ABABAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbabbabbb",
"output": "BBBABAABBBABAABBB"
},
{
"input": "bab",
"output": "BBABAAB"
},
{
"input": "aaabaa",
"output": "AABABAABAA"
},
{
"input": "aaa",
"output... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000030 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BABB', 'a')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BABB",
"a"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbab') == 'BBAB'
assert candidate('baabbbaa') == 'BAABBBAA'
assert candidate('bbababa') == 'BBABABA'
assert candidate('aab') == 'AAB'
assert candidate('baaaabbb') == 'BAA... | 40 | [
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "baabbbaa",
"output": "BAABBBAA"
},
{
"input": "bbababa",
"output": "BBABABA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "baaaabbb",
"output": "BAAAABBB"
},
{
"input": "abbbababa",
"output":... | [
{
"input": "bab",
"output": "BAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ababa",
"output": "ABABA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaaaabaa... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000031 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'abb')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"a",
"abb"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababa') == 'ABBABBBABBBABB'
assert candidate('aba') == 'ABBBABB'
assert candidate('ba') == 'BABB'
assert candidate('aaaaaa') == 'ABBABBABBABBABBABB'
assert candidate('aa... | 40 | [
{
"input": "aababa",
"output": "ABBABBBABBBABB"
},
{
"input": "aba",
"output": "ABBBABB"
},
{
"input": "ba",
"output": "BABB"
},
{
"input": "aaaaaa",
"output": "ABBABBABBABBABBABB"
},
{
"input": "aabbbbb",
"output": "ABBABBBBBBB"
},
{
"input": "abbab",... | [
{
"input": "bbbbbba",
"output": "BBBBBBABB"
},
{
"input": "abbbaaabb",
"output": "ABBBBBABBABBABBBB"
},
{
"input": "baaaabbb",
"output": "BABBABBABBABBBBB"
},
{
"input": "aaba",
"output": "ABBABBBABB"
},
{
"input": "aba",
"output": "ABBBABB"
},
{
"inpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000032 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('baab', 'bb')
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"baab",
"bb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'a'
assert candidate('babbbaba') == 'babbbaba'
assert candidate('b') == 'b'
assert candidate('baa') == 'baa'
assert candidate('bbb') == 'bbb'
assert candidate(... | 40 | [
{
"input": "a",
"output": "a"
},
{
"input": "babbbaba",
"output": "babbbaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "ababbbabb",
"output": "ababbbabb"
},
{
"i... | [
{
"input": "ab",
"output": "ab"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "bbbaabba",
"output": "bbbbba"
},
{
"input... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000033 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bb', 'bb')
s = s.upper()
s = s.replace('ABBA', 'aaaaa')
return s
| [
{
"method": "replace",
"args": [
"bb",
"bb"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"ABBA",
"aaaaa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abaa') == 'ABAA'
assert candidate('ab') == 'AB'
assert candidate('bababaa') == 'BABABAA'
assert candidate('ba') == 'BA'
assert candidate('bbaa') == 'BBAA'
assert cand... | 40 | [
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "babaaabbbb",
"output": "BABAAABBBB"
},
... | [
{
"input": "baaaaab",
"output": "BAAAAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "babbaa",
"output": "BaaaaaA"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "aaa... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000034 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('ba', 'aabba')
s = s.replace('bb', 'abb')
s = s.replace('b', 'bbaab')
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"ba",
"aabba"
]
},
{
"method": "replace",
"args": [
"bb",
"abb"
]
},
{
"method": "replace",
"args": [
"b",
"bbaab"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbbaaba') == 'abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba'
assert candidate('baaabaabab') == 'aaabbaabbbaabaaaaaabbaabbbaabaaaaabbaabbbaababbaab'
assert candidate('abaaaabb') ... | 40 | [
{
"input": "bbbbaaba",
"output": "abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba"
},
{
"input": "baaabaabab",
"output": "aaabbaabbbaabaaaaaabbaabbbaabaaaaabbaabbbaababbaab"
},
{
"input": "abaaaabb",
"output": "aaaabbaabbbaabaaaaabbaabbbaab"
},
{
"input": "a",
"output": "a"... | [
{
"input": "aabbaaa",
"output": "aabbaabaaabbaabbbaabaaa"
},
{
"input": "aaabbbaa",
"output": "aaaabbaabbbaabaaabbaabbbaabaa"
},
{
"input": "ba",
"output": "aaabbaabbbaaba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "baaabababa",
"output": "aaabbaabbbaab... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000035 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaaa', 'ababb')
s = s.lower()
s = s.lower()
s = s.replace('aaaba', 'baa')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"aaaa",
"ababb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"aaaba",
"baa"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babbaaaaa') == 'BABBABABBA'
assert candidate('ab') == 'AB'
assert candidate('baabaaba') == 'BAABAABA'
assert candidate('baaaabaabb') == 'BABABBBAABB'
assert candidate('ba... | 40 | [
{
"input": "babbaaaaa",
"output": "BABBABABBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "baabaaba",
"output": "BAABAABA"
},
{
"input": "baaaabaabb",
"output": "BABABBBAABB"
},
{
"input": "babbaabbb",
"output": "BABBAABBB"
},
{
"input": "abaabab... | [
{
"input": "aba",
"output": "ABA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaaa",
"output": "BABABB"
},
{
"input": "abb",
"outp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000036 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('ABAB', 'babb')
s = s.replace('bBA', 'baa')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"ABAB",
"babb"
]
},
{
"method": "replace",
"args": [
"bBA",
"baa"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbaaaba') == 'ABBAAABA'
assert candidate('ba') == 'BA'
assert candidate('baababbaaa') == 'BABABBAAAA'
assert candidate('aaaaaabb') == 'AAAAAABB'
assert candidate('aaaabb... | 40 | [
{
"input": "abbaaaba",
"output": "ABBAAABA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baababbaaa",
"output": "BABABBAAAA"
},
{
"input": "aaaaaabb",
"output": "AAAAAABB"
},
{
"input": "aaaabbbbb",
"output": "AAAABBBBB"
},
{
"input": "aaa",
"... | [
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "aababaaabb",
"output": "ABABBAAABB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "a",
"output": "A"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000037 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbabb') == 'bbabb'
assert candidate('bbaba') == 'bbaba'
assert candidate('babbabaabb') == 'babbabaabb'
assert candidate('aabbababaa') == 'aabbababaa'
assert candidate('b'... | 40 | [
{
"input": "bbabb",
"output": "bbabb"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "babbabaabb",
"output": "babbabaabb"
},
{
"input": "aabbababaa",
"output": "aabbababaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
... | [
{
"input": "bbb",
"output": "bbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbaaaba",
"output": "bbaaaba"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "babab",
"output": "babab"
},
{
"inp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000038 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ababbabbab') == 'ababbabbab'
assert candidate('abaabbbba') == 'abaabbbba'
assert candidate('bbbab') == 'bbbab'
assert candidate('bbbb') == 'bbbb'
assert candidate('baabab... | 40 | [
{
"input": "ababbabbab",
"output": "ababbabbab"
},
{
"input": "abaabbbba",
"output": "abaabbbba"
},
{
"input": "bbbab",
"output": "bbbab"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "baababb",
"output": "baababb"
},
{
"input": "a",
"output... | [
{
"input": "a",
"output": "a"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbaba",
"output": "abbbaba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "abbaaabaa",
"output": "abbaaabaa"
},
{
"input": "baaab",
"output": "baaab"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000039 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'A'
assert candidate('baabbbb') == 'BAABBBB'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('a') == 'A'
assert candidate('aa') ... | 40 | [
{
"input": "a",
"output": "A"
},
{
"input": "baabbbb",
"output": "BAABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babaaaa",
... | [
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "bbabbbaab",
"output": "BBABBBAAB"
},
{
"input": "aababaaba",
"output": "AABABAABA"
},
{
"input": "babbbaaaa",
"output": "BABBBAAAA"
},
{
"input": "aaaaabaa",
"output": "AAAAABAA"
},
{
"input": "aab... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000040 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabab') == 'aabab'
assert candidate('babbbb') == 'babbbb'
assert candidate('a') == 'a'
assert candidate('ab') == 'ab'
assert candidate('babb') == 'babb'
assert candid... | 40 | [
{
"input": "aabab",
"output": "aabab"
},
{
"input": "babbbb",
"output": "babbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "bbabbb",
"output": "bbabbb"
},
{
"inp... | [
{
"input": "aabbbabaa",
"output": "aabbbabaa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabaabb",
"output": "aabaabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aaabaab",
"output": "aaabaab"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000041 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbb') == 'bbbb'
assert candidate('b') == 'b'
assert candidate('ba') == 'ba'
assert candidate('baa') == 'baa'
assert candidate('babba') == 'babba'
assert candidate('b... | 40 | [
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "babba",
"output": "babba"
},
{
"input": "babaab",
"output": "babaab"
},
{
"input": "... | [
{
"input": "aababbaaa",
"output": "aababbaaa"
},
{
"input": "bbabbaab",
"output": "bbabbaab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "baaabbbba",
"output": "baaabbbba"
},
{
"input": "baaaaaaa",
"output": "baaaaaaa"
},
{
"input": "aab",
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000042 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'abaaa')
s = s.upper()
s = s.upper()
s = s.replace('AABA', 'baaa')
s = s.replace('aA', 'baabb')
return s
| [
{
"method": "replace",
"args": [
"a",
"abaaa"
]
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AABA",
"baaa"
]
},
{
"method": "replace",
"args": [
"aA",
"ba... | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aab') == 'ABAAbaabaabbAB'
assert candidate('b') == 'B'
assert candidate('a') == 'ABAAA'
assert candidate('aaabbba') == 'ABAAbaabaabbbaabaabbABBBABAAA'
assert candidate('a... | 40 | [
{
"input": "aab",
"output": "ABAAbaabaabbAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "aaabbba",
"output": "ABAAbaabaabbbaabaabbABBBABAAA"
},
{
"input": "abbaaaa",
"output": "ABAAABBABAAbaabaabbbaabaabbbaabaabbA"
},... | [
{
"input": "ababba",
"output": "ABAbaaaBAAABBABAAA"
},
{
"input": "bbbaabb",
"output": "BBBABAAbaabaabbABB"
},
{
"input": "aaabaaabbb",
"output": "ABAAbaabaabbbaaabaaaBAAbaabaabbbaabaabbABBB"
},
{
"input": "ba",
"output": "BABAAA"
},
{
"input": "babbba",
"outp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000043 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('b', 'aaa')
s = s.replace('aaaaa', 'bbabb')
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"b",
"aaa"
]
},
{
"method": "replace",
"args": [
"aaaaa",
"bbabb"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbbbabb') == 'BBABBBBABBBBABBBBABBAA'
assert candidate('a') == 'A'
assert candidate('babbbb') == 'BBABBBBABBBBABBA'
assert candidate('aaaabaa') == 'BBABBAAAA'
assert can... | 40 | [
{
"input": "bbbbbabb",
"output": "BBABBBBABBBBABBBBABBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbbb",
"output": "BBABBBBABBBBABBA"
},
{
"input": "aaaabaa",
"output": "BBABBAAAA"
},
{
"input": "bbbabb",
"output": "BBABBBBABBBBABBA"
},
{
"in... | [
{
"input": "baababab",
"output": "BBABBBBABBBBABBA"
},
{
"input": "b",
"output": "AAA"
},
{
"input": "bbbababbab",
"output": "BBABBBBABBBBABBBBABBAAAA"
},
{
"input": "aaaaaabba",
"output": "BBABBBBABBAAA"
},
{
"input": "ab",
"output": "AAAA"
},
{
"inpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000044 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
s = s.lower()
s = s.upper()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaabb') == 'BBAABB'
assert candidate('bbabaa') == 'BBABAA'
assert candidate('abbaaba') == 'ABBAABA'
assert candidate('bbaaabaa') == 'BBAAABAA'
assert candidate('baaab') ... | 40 | [
{
"input": "bbaabb",
"output": "BBAABB"
},
{
"input": "bbabaa",
"output": "BBABAA"
},
{
"input": "abbaaba",
"output": "ABBAABA"
},
{
"input": "bbaaabaa",
"output": "BBAAABAA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "abaaaaab",
"outpu... | [
{
"input": "abaaabbb",
"output": "ABAAABBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babbaabb",
"output": "BABBAABB"
},
{
"input": "babaaa",
"output": "BABAAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aabbbbbbb",
"output": "AABBBB... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000045 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ba') == 'ba'
assert candidate('bababb') == 'bababb'
assert candidate('aababbb') == 'aababbb'
assert candidate('abba') == 'abba'
assert candidate('aabba') == 'aabba'
a... | 40 | [
{
"input": "ba",
"output": "ba"
},
{
"input": "bababb",
"output": "bababb"
},
{
"input": "aababbb",
"output": "aababbb"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "bbabbba",
"output": "bbabbba"
}... | [
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "baaabaaabb",
"output": "baaabaaabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "abbaabab",
"output": "abbaabab"
},
{
"input": "ababbbbaaa",
"output": "ababbbbaaa"
},
{
"input": "bbab",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000046 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
s = s.replace('B', 'aaa')
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"B",
"aaa"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baab') == 'AAAAAAAA'
assert candidate('bababaab') == 'AAAAAAAAAAAAAAAA'
assert candidate('aabaababab') == 'AAAAAAAAAAAAAAAAAA'
assert candidate('ba') == 'AAAA'
assert can... | 40 | [
{
"input": "baab",
"output": "AAAAAAAA"
},
{
"input": "bababaab",
"output": "AAAAAAAAAAAAAAAA"
},
{
"input": "aabaababab",
"output": "AAAAAAAAAAAAAAAAAA"
},
{
"input": "ba",
"output": "AAAA"
},
{
"input": "bbaabba",
"output": "AAAAAAAAAAAAAAA"
},
{
"in... | [
{
"input": "aababaaaab",
"output": "AAAAAAAAAAAAAAAA"
},
{
"input": "babb",
"output": "AAAAAAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbbaba",
"output": "AAAAAAAAAAAAAAAAA"
},
{
"input": "bbabbbaba",
"output": "AAAAAAAAAAAAAAAAAAAAA"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000047 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.replace('ba', 'bb')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"ba",
"bb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabbb') == 'aaabbb'
assert candidate('baaaabba') == 'bbaaabbb'
assert candidate('aaabba') == 'aaabbb'
assert candidate('baaa') == 'bbaa'
assert candidate('b') == 'b'
... | 40 | [
{
"input": "aaabbb",
"output": "aaabbb"
},
{
"input": "baaaabba",
"output": "bbaaabbb"
},
{
"input": "aaabba",
"output": "aaabbb"
},
{
"input": "baaa",
"output": "bbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
... | [
{
"input": "aab",
"output": "aab"
},
{
"input": "abbbbabaa",
"output": "abbbbbbba"
},
{
"input": "bbbab",
"output": "bbbbb"
},
{
"input": "bbaabbbaba",
"output": "bbbabbbbbb"
},
{
"input": "abbaabb",
"output": "abbbabb"
},
{
"input": "aa",
"output"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000048 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbab') == 'BBAB'
assert candidate('ababaabab') == 'ABABAABAB'
assert candidate('babaaaa') == 'BABAAAA'
assert candidate('abbbbaaa') == 'ABBBBAAA'
assert candidate('babbaa... | 40 | [
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "ababaabab",
"output": "ABABAABAB"
},
{
"input": "babaaaa",
"output": "BABAAAA"
},
{
"input": "abbbbaaa",
"output": "ABBBBAAA"
},
{
"input": "babbaabab",
"output": "BABBAABAB"
},
{
"input": "aaabbaaabb"... | [
{
"input": "baabbbbaa",
"output": "BAABBBBAA"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "babbaab",
"output": "BABBAAB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "bbabbbab",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000049 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbaaaaaa') == 'ABBAAAAAA'
assert candidate('bb') == 'BB'
assert candidate('bbaabbbbaa') == 'BBAABBBBAA'
assert candidate('baabbba') == 'BAABBBA'
assert candidate('bababa... | 40 | [
{
"input": "abbaaaaaa",
"output": "ABBAAAAAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbaabbbbaa",
"output": "BBAABBBBAA"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "aa",
"outpu... | [
{
"input": "ab",
"output": "AB"
},
{
"input": "bbabbba",
"output": "BBABBBA"
},
{
"input": "aabbbbbab",
"output": "AABBBBBAB"
},
{
"input": "aaabbaba",
"output": "AAABBABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabbbaaaa",
"output": "AAA... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000050 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaba', 'bbbb')
return s
| [
{
"method": "replace",
"args": [
"aaba",
"bbbb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babababbb') == 'babababbb'
assert candidate('bbbb') == 'bbbb'
assert candidate('babba') == 'babba'
assert candidate('aab') == 'aab'
assert candidate('ba') == 'ba'
ass... | 40 | [
{
"input": "babababbb",
"output": "babababbb"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "babba",
"output": "babba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "baaa",
"output": "baaa"
},
{
... | [
{
"input": "bab",
"output": "bab"
},
{
"input": "bbabbbbaa",
"output": "bbabbbbaa"
},
{
"input": "aabbaaab",
"output": "aabbaaab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ababbbbba",
"output": "ababbbbba"
},
{
"input": "aaabaab",
"output":... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000051 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaaa') == 'BABAAA'
assert candidate('a') == 'A'
assert candidate('baba') == 'BABA'
assert candidate('bbbbbaabb') == 'BBBBBAABB'
assert candidate('aabaa') == 'AABAA'
... | 40 | [
{
"input": "babaaa",
"output": "BABAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "bbbbbaabb",
"output": "BBBBBAABB"
},
{
"input": "aabaa",
"output": "AABAA"
},
{
"input": "abaaab",
"output": "ABAAAB"
}... | [
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "bbaaabaa",
"output": "BBAAABAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "abaababbba",
"output": "ABAABABBBA"
},
{
"input": "ab",
"output": "AB"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000052 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aba') == 'ABA'
assert candidate('baabaa') == 'BAABAA'
assert candidate('baabbb') == 'BAABBB'
assert candidate('ababaab') == 'ABABAAB'
assert candidate('baaabaa') == 'BAAA... | 40 | [
{
"input": "aba",
"output": "ABA"
},
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "baabbb",
"output": "BAABBB"
},
{
"input": "ababaab",
"output": "ABABAAB"
},
{
"input": "baaabaa",
"output": "BAAABAA"
},
{
"input": "bbb",
"output": "BBB"
... | [
{
"input": "aaaaabb",
"output": "AAAAABB"
},
{
"input": "ababaaaabb",
"output": "ABABAAAABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababbbbab",
"output": "BABABBBBAB"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000053 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'bbb')
s = s.replace('bbb', 'aabb')
s = s.lower()
s = s.replace('bbaab', 'a')
return s
| [
{
"method": "replace",
"args": [
"a",
"bbb"
]
},
{
"method": "replace",
"args": [
"bbb",
"aabb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bbaab",
"a"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaa') == 'aaabaabb'
assert candidate('bb') == 'bb'
assert candidate('aababb') == 'aaabaaab'
assert candidate('aba') == 'aaabb'
assert candidate('b') == 'b'
assert can... | 40 | [
{
"input": "aaa",
"output": "aaabaabb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aababb",
"output": "aaabaaab"
},
{
"input": "aba",
"output": "aaabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbbbbabab",
"output": "aaabaaabaabbb"
}... | [
{
"input": "aabb",
"output": "aaabbb"
},
{
"input": "babbbabaa",
"output": "aaabaaabaabbbb"
},
{
"input": "aba",
"output": "aaabb"
},
{
"input": "baaabbbba",
"output": "aaabaaabaabbbb"
},
{
"input": "aababaaa",
"output": "aaabaaabaaabbb"
},
{
"input": ... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000054 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'b'
assert candidate('ab') == 'ab'
assert candidate('aabbbbaa') == 'aabbbbaa'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('babbaba') == 'babbaba'
ass... | 40 | [
{
"input": "b",
"output": "b"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aabbbbaa",
"output": "aabbbbaa"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "babbaba",
"output": "babbaba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
... | [
{
"input": "bbbabaa",
"output": "bbbabaa"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abaaaa",
"output": "abaaaa"
},
{
"input": "abaababbba",
"output": "abaababbba"
},
{
"input": "aabbaab",
"output":... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000055 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('bbbb', 'ba')
s = s.replace('aab', 'aaa')
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bbbb",
"ba"
]
},
{
"method": "replace",
"args": [
"aab",
"aaa"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbabbabab') == 'ABBABBABAB'
assert candidate('bbabb') == 'BBABB'
assert candidate('babbab') == 'BABBAB'
assert candidate('aaababaa') == 'AAAAABAA'
assert candidate('aaab... | 40 | [
{
"input": "abbabbabab",
"output": "ABBABBABAB"
},
{
"input": "bbabb",
"output": "BBABB"
},
{
"input": "babbab",
"output": "BABBAB"
},
{
"input": "aaababaa",
"output": "AAAAABAA"
},
{
"input": "aaababba",
"output": "AAAAABBA"
},
{
"input": "a",
"ou... | [
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "babbabb",
"output": "BABBABB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbaabbbba",
"output": "BBAAAAA"
},
{
"input": "baaab",
"output": "BAAAA"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000056 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.replace('abbb', 'abbb')
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abbb",
"abbb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbbba') == 'ABBBBBA'
assert candidate('aba') == 'ABA'
assert candidate('b') == 'B'
assert candidate('bbbaaabaa') == 'BBBAAABAA'
assert candidate('aabbbaa') == 'AABBBAA'... | 40 | [
{
"input": "abbbbba",
"output": "ABBBBBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbaaabaa",
"output": "BBBAAABAA"
},
{
"input": "aabbbaa",
"output": "AABBBAA"
},
{
"input": "abaabbaab",
"output": "ABAA... | [
{
"input": "aab",
"output": "AAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "aaabaaa",
"output": "AAABAAA"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "abbabbbbb",
"output": "ABBABBBBB"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000057 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
s = s.replace('BAB', 'aba')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAB",
"aba"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('aab') == 'AAB'
assert candidate('aa') == 'AA'
assert candidate('aababaab') == 'AAabaAAB'
assert candidate('ababababba') == 'AabaAabaBA'
a... | 40 | [
{
"input": "b",
"output": "B"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aababaab",
"output": "AAabaAAB"
},
{
"input": "ababababba",
"output": "AabaAabaBA"
},
{
"input": "babbbab",
"output": "abaBaba"
}... | [
{
"input": "aabab",
"output": "AAaba"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "babaab",
"output": "abaAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbabbaba",
"output": "BBabaabaA"
},
{
"input": "babababba",
"output": "abaAabaBA"
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000058 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbb', 'aaa')
s = s.lower()
return s
| [
{
"method": "replace",
"args": [
"bbb",
"aaa"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'babaa'
assert candidate('bba') == 'bba'
assert candidate('aabba') == 'aabba'
assert candidate('bbbbbb') == 'aaaaaa'
assert candidate('abaabbaa') == 'abaabbaa'... | 40 | [
{
"input": "babaa",
"output": "babaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "bbbbbb",
"output": "aaaaaa"
},
{
"input": "abaabbaa",
"output": "abaabbaa"
},
{
"input": "bbabbbab",
"output": "bbaaa... | [
{
"input": "aba",
"output": "aba"
},
{
"input": "aaabbba",
"output": "aaaaaaa"
},
{
"input": "baaabba",
"output": "baaabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabbaa",
"output": "aabbaa"
},
{
"input": "baaaaaabb",
"output": "baaaaaabb"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000059 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabba') == 'AABBA'
assert candidate('ababbbbaba') == 'ABABBBBABA'
assert candidate('aabbab') == 'AABBAB'
assert candidate('abbbbabb') == 'ABBBBABB'
assert candidate('aaab... | 40 | [
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "ababbbbaba",
"output": "ABABBBBABA"
},
{
"input": "aabbab",
"output": "AABBAB"
},
{
"input": "abbbbabb",
"output": "ABBBBABB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "aba",
"output":... | [
{
"input": "abbbbbabb",
"output": "ABBBBBABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "baabaaabb",
"output": "BAABAAABB"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "bb",
"output": "BB"
},
{
"input... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000060 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('baab', 'bbaa')
return s
| [
{
"method": "replace",
"args": [
"baab",
"bbaa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'a'
assert candidate('ababbab') == 'ababbab'
assert candidate('baaaa') == 'baaaa'
assert candidate('aabab') == 'aabab'
assert candidate('abba') == 'abba'
asser... | 40 | [
{
"input": "a",
"output": "a"
},
{
"input": "ababbab",
"output": "ababbab"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "baabababaa",
"output": "bbaaababaa"
... | [
{
"input": "babba",
"output": "babba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "abbabab",
"output": "abbabab"
},
{
"input": "bbbbaaaabb",
"output": "bbbbaaaabb"
},
{
"input": "bbbbbbb",
"output": "bbbbbbb"
},
{
"input": "abaababb",
"output"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000061 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ababb') == 'ABABB'
assert candidate('ababaabbb') == 'ABABAABBB'
assert candidate('b') == 'B'
assert candidate('aaabaab') == 'AAABAAB'
assert candidate('aababb') == 'AABAB... | 40 | [
{
"input": "ababb",
"output": "ABABB"
},
{
"input": "ababaabbb",
"output": "ABABAABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaabaab",
"output": "AAABAAB"
},
{
"input": "aababb",
"output": "AABABB"
},
{
"input": "aaaaa",
"output": "AAAAA"... | [
{
"input": "bbabaaa",
"output": "BBABAAA"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbaaaaa",
"output": "ABBAAAAA"
},
{
"input": "aabbbbabba",
"output": "AABBBBABBA"
},
{
"input": "babbbaba",
"output": "BABBBABA"
},
{
"input": "abba",
"o... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000062 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baa') == 'BAA'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('abaaa') == 'ABAAA'
assert candidate('bbbaba') == 'BBBABA'
assert candidate(... | 40 | [
{
"input": "baa",
"output": "BAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "bbbaba",
"output": "BBBABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "babbba",... | [
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbbababab",
"output": "BBBABABAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "bbbaaaaba",
"output": "BBBAAAABA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "babb",
"output": "BABB"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000063 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbbb', 'aaaba')
s = s.lower()
return s
| [
{
"method": "replace",
"args": [
"bbbb",
"aaaba"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'babaa'
assert candidate('abbba') == 'abbba'
assert candidate('a') == 'a'
assert candidate('baababb') == 'baababb'
assert candidate('aaaaaaaabb') == 'aaaaaaaab... | 40 | [
{
"input": "babaa",
"output": "babaa"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "a",
"output": "a"
},
{
"input": "baababb",
"output": "baababb"
},
{
"input": "aaaaaaaabb",
"output": "aaaaaaaabb"
},
{
"input": "abbaa",
"output": "abbaa"... | [
{
"input": "abb",
"output": "abb"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbbababbb",
"output": "aaabaababbb"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000064 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('bbaba') == 'BBABA'
assert candidate('b') == 'B'
assert candidate('bababaaa') == 'BABABAAA'
assert candidate('baaababbaa') == 'BAA... | 40 | [
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "bbaba",
"output": "BBABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababaaa",
"output": "BABABAAA"
},
{
"input": "baaababbaa",
"output": "BAAABABBAA"
},
{
"input": "baaabbb",
"output":... | [
{
"input": "baa",
"output": "BAA"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "abbaba",
"output": "ABBABA"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "babbbaab",
"output": "BABBBAAB"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000065 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbabb', 'baabb')
return s
| [
{
"method": "replace",
"args": [
"bbabb",
"baabb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'b'
assert candidate('babbab') == 'babbab'
assert candidate('bababbbbb') == 'bababbbbb'
assert candidate('bbbbabab') == 'bbbbabab'
assert candidate('aaababbab') ==... | 40 | [
{
"input": "b",
"output": "b"
},
{
"input": "babbab",
"output": "babbab"
},
{
"input": "bababbbbb",
"output": "bababbbbb"
},
{
"input": "bbbbabab",
"output": "bbbbabab"
},
{
"input": "aaababbab",
"output": "aaababbab"
},
{
"input": "baaabaab",
"out... | [
{
"input": "b",
"output": "b"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "abaaabbbb",
"output": "abaaabbbb"
},
{
"input": "bbabaaba",
"output": "bbabaaba"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000066 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('bbbbab') == 'BBBBAB'
assert candidate('aaa') == 'AAA'
assert candidate('baab') == 'BAAB'
assert candidate('baa') == 'BAA'
assert candidat... | 40 | [
{
"input": "b",
"output": "B"
},
{
"input": "bbbbab",
"output": "BBBBAB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "... | [
{
"input": "bba",
"output": "BBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "ababbbaab",
"output": "ABABBBAAB"
},
{
"input": "baaaabbb",
"output": "BAAAABBB"
},
{
"input": "a",
"output": "A"
},
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000067 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabbaab') == 'aabbaab'
assert candidate('bbbbaaaba') == 'bbbbaaaba'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('aba') == 'aba'
assert candidate('bbbb') == ... | 40 | [
{
"input": "aabbaab",
"output": "aabbaab"
},
{
"input": "bbbbaaaba",
"output": "bbbbaaaba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "bbbbba",
"output": "b... | [
{
"input": "a",
"output": "a"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aabbbbaa",
"output": "aabbbbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbabaabbaa",
"output": "bbabaabbaa"
},
{
"input": "babb",
"output": "babb"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000068 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aa', 'bbaab')
s = s.replace('abba', 'a')
return s
| [
{
"method": "replace",
"args": [
"aa",
"bbaab"
]
},
{
"method": "replace",
"args": [
"abba",
"a"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaaa') == 'bbaabbbaab'
assert candidate('aaabaaaab') == 'bbaababbbaabbbaabb'
assert candidate('babb') == 'babb'
assert candidate('babbabb') == 'babb'
assert candidate('ab... | 40 | [
{
"input": "aaaa",
"output": "bbaabbbaab"
},
{
"input": "aaabaaaab",
"output": "bbaababbbaabbbaabb"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "babbabb",
"output": "babb"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "aabbbaa",
"ou... | [
{
"input": "a",
"output": "a"
},
{
"input": "ababbbaabb",
"output": "ababbbbbaabbb"
},
{
"input": "abbbbbba",
"output": "abbbbbba"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "abbbbaabb",
"output": "abbbbbbaabbb"
},
{
"input": "baabbabb",
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000069 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.replace('bba', 'aaa')
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bba",
"aaa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baabbb') == 'baabbb'
assert candidate('abbbb') == 'abbbb'
assert candidate('abaaba') == 'abaaba'
assert candidate('a') == 'a'
assert candidate('bababbbbba') == 'bababbbaa... | 40 | [
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "abaaba",
"output": "abaaba"
},
{
"input": "a",
"output": "a"
},
{
"input": "bababbbbba",
"output": "bababbbaaa"
},
{
"input": "baaba",
"output": "baaba"... | [
{
"input": "ababbabaa",
"output": "abaaaabaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aaaabaaaa",
"output": "aaaabaaaa"
},
{
"input": "bababbbbab",
"output": "bababbaaab"
},
{
"input": "bbbbab",
"output": "bbaaab"
},
{
"input": "baab",
"o... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000070 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaabba') == 'bbaabba'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('abbb') == 'abbb'
assert candidate('aa') == 'aa'
assert candidate('aba') == 'aba'
ass... | 40 | [
{
"input": "bbaabba",
"output": "bbaabba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "abba",
"output": "abba"
},
{
... | [
{
"input": "aababa",
"output": "aababa"
},
{
"input": "baabbbab",
"output": "baabbbab"
},
{
"input": "aabbba",
"output": "aabbba"
},
{
"input": "abaaabba",
"output": "abaaabba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbabababaa",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000071 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('AB', 'bbb')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AB",
"bbb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabaaa') == 'AbbbAAA'
assert candidate('bbbabbaa') == 'BBBbbbBAA'
assert candidate('bbbab') == 'BBBbbb'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('bbbabb') ... | 40 | [
{
"input": "aabaaa",
"output": "AbbbAAA"
},
{
"input": "bbbabbaa",
"output": "BBBbbbBAA"
},
{
"input": "bbbab",
"output": "BBBbbb"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "bbbabb",
"output": "BBBbbbB"
},
{
"input": "bab",
"output":... | [
{
"input": "abbbbaab",
"output": "bbbBBBAbbb"
},
{
"input": "aabbaaabab",
"output": "AbbbBAAbbbbbb"
},
{
"input": "a",
"output": "A"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaaba",
"output": "AAAbbbA"
},
{
"input": "aab",
"output": "Abbb"
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000072 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaaab') == 'BBAAAAB'
assert candidate('a') == 'A'
assert candidate('aa') == 'AA'
assert candidate('bb') == 'BB'
assert candidate('baaabbba') == 'BAAABBBA'
assert ca... | 40 | [
{
"input": "bbaaaab",
"output": "BBAAAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaabbba",
"output": "BAAABBBA"
},
{
"input": "aabaaabb",
"output": "AABAAABB"
},
{
... | [
{
"input": "baa",
"output": "BAA"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "abbbbab",
"output": "ABBBBAB"
},
{
"input": "abaaaaabba",
"output": "ABAAAAABBA"
},
{
"input": "aaababb",
"output": "AAABABB"
},
{
"input": "abbabbbb",
"output"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000073 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('baa', 'abba')
s = s.replace('a', 'ba')
s = s.lower()
s = s.lower()
return s
| [
{
"method": "replace",
"args": [
"baa",
"abba"
]
},
{
"method": "replace",
"args": [
"a",
"ba"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaaab') == 'babababab'
assert candidate('babaa') == 'bbababbba'
assert candidate('aabbbbaa') == 'bababbbbabbba'
assert candidate('bbababbb') == 'bbbabbabbb'
assert candid... | 40 | [
{
"input": "aaaab",
"output": "babababab"
},
{
"input": "babaa",
"output": "bbababbba"
},
{
"input": "aabbbbaa",
"output": "bababbbbabbba"
},
{
"input": "bbababbb",
"output": "bbbabbabbb"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bab",
"o... | [
{
"input": "aa",
"output": "baba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "a",
"output": "ba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbbbb",
"output": "bbbbb"
},
{
"input": "aabaaabbb",
"output": "babababbbababbb"
},
{
"in... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000074 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('BAAA', 'a')
s = s.replace('BABA', 'a')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAAA",
"a"
]
},
{
"method": "replace",
"args": [
"BABA",
"a"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babb') == 'BABB'
assert candidate('baaa') == 'a'
assert candidate('bbbb') == 'BBBB'
assert candidate('bbaa') == 'BBAA'
assert candidate('ab') == 'AB'
assert candidate... | 40 | [
{
"input": "babb",
"output": "BABB"
},
{
"input": "baaa",
"output": "a"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aa"... | [
{
"input": "baab",
"output": "BAAB"
},
{
"input": "bbaaabbbba",
"output": "BaBBBBA"
},
{
"input": "ababaabbba",
"output": "AaABBBA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "ababb",
"output": "ABABB"
},
{
"input": "aaababab",
"output": ... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000075 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('babab', 'b')
s = s.replace('bbb', 'baabb')
s = s.upper()
s = s.upper()
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"babab",
"b"
]
},
{
"method": "replace",
"args": [
"bbb",
"baabb"
]
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbb') == 'ABAABBB'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('baab') == 'BAAB'
assert candidate('bab') == 'BAB'
assert candidate('b... | 40 | [
{
"input": "abbbb",
"output": "ABAABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "bbbbbbbaab",
"output": "BAABBBAABBBAAB"
},
{
... | [
{
"input": "aba",
"output": "ABA"
},
{
"input": "bbbab",
"output": "BAABBAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aaabaaaa",
"output": "AAABAAAA"
},
{
"input": "baababaab",
"output": "BAABABAAB"
},
{
"input": "aaababab",
"output": "AAA... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000076 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bb') == 'bb'
assert candidate('bb') == 'bb'
assert candidate('abbbaaaa') == 'abbbaaaa'
assert candidate('aaaaaaaaba') == 'aaaaaaaaba'
assert candidate('babababba') == 'ba... | 40 | [
{
"input": "bb",
"output": "bb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abbbaaaa",
"output": "abbbaaaa"
},
{
"input": "aaaaaaaaba",
"output": "aaaaaaaaba"
},
{
"input": "babababba",
"output": "babababba"
},
{
"input": "babaababb",
"output... | [
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "abababaa",
"output": "abababaa"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "bbbababba",
"output": "bbbababba"
},
{
"input": "ab",
"output": "ab"
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000077 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabba') == 'aaabba'
assert candidate('abbb') == 'abbb'
assert candidate('abbbaaaab') == 'abbbaaaab'
assert candidate('aba') == 'aba'
assert candidate('aaaa') == 'aaaa'
... | 40 | [
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "abbbaaaab",
"output": "abbbaaaab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "aab",
"output": "aab"
},
... | [
{
"input": "abab",
"output": "abab"
},
{
"input": "bbaababb",
"output": "bbaababb"
},
{
"input": "bbbbaba",
"output": "bbbbaba"
},
{
"input": "babababbab",
"output": "babababbab"
},
{
"input": "ababbaa",
"output": "ababbaa"
},
{
"input": "bba",
"ou... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000078 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bba', 'bab')
s = s.upper()
s = s.replace('AB', 'aa')
return s
| [
{
"method": "replace",
"args": [
"bba",
"bab"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AB",
"aa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaabbaaa') == 'BaaAaaaaAA'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('bbaabbb') == 'BaaaaBB'
assert candidate('a') == 'A'
assert candidate('aababbaba') ==... | 40 | [
{
"input": "bbaaabbaaa",
"output": "BaaAaaaaAA"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "bbaabbb",
"output": "BaaaaBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aababbaba",
"output": "AaaaaaaBA"
},
{
"input": "aabababbab",
"o... | [
{
"input": "a",
"output": "A"
},
{
"input": "bbabbbbbab",
"output": "BaaBBBBaaB"
},
{
"input": "abbb",
"output": "aaBB"
},
{
"input": "aab",
"output": "Aaa"
},
{
"input": "baababaa",
"output": "BAaaaaAA"
},
{
"input": "abaaa",
"output": "aaAAA"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000079 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('abb', 'b')
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abb",
"b"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ba') == 'ba'
assert candidate('abbbababab') == 'bbababab'
assert candidate('aabbbaa') == 'abbaa'
assert candidate('bbabaaab') == 'bbabaaab'
assert candidate('babbaaaa') =... | 40 | [
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbababab",
"output": "bbababab"
},
{
"input": "aabbbaa",
"output": "abbaa"
},
{
"input": "bbabaaab",
"output": "bbabaaab"
},
{
"input": "babbaaaa",
"output": "bbaaaa"
},
{
"input": "abbbaabb",
"outpu... | [
{
"input": "abaa",
"output": "abaa"
},
{
"input": "abaaaaab",
"output": "abaaaaab"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "aaaaaab",
"output": "aaaaaab"
},
{
"input": "aaaaabbbb",
"output": "aaaabbb"
},
{
"input": "bbabbbbb",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000080 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('bab', 'ab')
s = s.upper()
s = s.replace('BABB', 'aabb')
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bab",
"ab"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BABB",
"aabb"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabbbbabbb') == 'AABBaabbB'
assert candidate('aabbaaabab') == 'AABBAAAAB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('abbb') == 'ABBB'
assert candidate('ababab... | 40 | [
{
"input": "aabbbbabbb",
"output": "AABBaabbB"
},
{
"input": "aabbaaabab",
"output": "AABBAAAAB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "ababab",
"output": "AABAB"
},
{
"input": "ab",
"output":... | [
{
"input": "babb",
"output": "ABB"
},
{
"input": "bbaaabab",
"output": "BBAAAAB"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "a",
"output": "A"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000081 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'a'
assert candidate('aaba') == 'aaba'
assert candidate('baaaaababa') == 'baaaaababa'
assert candidate('babbbababb') == 'babbbababb'
assert candidate('baabaabb') =... | 40 | [
{
"input": "a",
"output": "a"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "baaaaababa",
"output": "baaaaababa"
},
{
"input": "babbbababb",
"output": "babbbababb"
},
{
"input": "baabaabb",
"output": "baabaabb"
},
{
"input": "abaaaaba",
"out... | [
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "aaaabbabb",
"output": "aaaabbabb"
},
{
"input": "abaabaaa",
"output": "abaabaaa"
},
{
"input": "bbaababaa",
"output": "bbaababaa"
},
{
"input": "abba",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000082 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abab') == 'abab'
assert candidate('bababa') == 'bababa'
assert candidate('aaabba') == 'aaabba'
assert candidate('bbbbaaab') == 'bbbbaaab'
assert candidate('bbbbabb') == '... | 40 | [
{
"input": "abab",
"output": "abab"
},
{
"input": "bababa",
"output": "bababa"
},
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "bbbbaaab",
"output": "bbbbaaab"
},
{
"input": "bbbbabb",
"output": "bbbbabb"
},
{
"input": "bbababbba",
"output... | [
{
"input": "ababa",
"output": "ababa"
},
{
"input": "bbabaa",
"output": "bbabaa"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "bbbbababb",
"output": "bbbbababb"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "b",
"output": "b"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000083 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('BAA', 'b')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAA",
"b"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaaab') == 'BBAAB'
assert candidate('b') == 'B'
assert candidate('bababb') == 'BABABB'
assert candidate('bbbbbaba') == 'BBBBBABA'
assert candidate('aab') == 'AAB'
a... | 40 | [
{
"input": "bbaaaab",
"output": "BBAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababb",
"output": "BABABB"
},
{
"input": "bbbbbaba",
"output": "BBBBBABA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "a",
"output": "A"
},
{
"i... | [
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aabaa",
"output": "AAB"
},
{
"input": "bbbbbbaaba",
"output": "BBBBBBBA"
},
{
"input": "abaabbbabb",
"output": "ABBBBABB"
},
{
"input": "aaabbbbaab",
"output": "A... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000084 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('A', 'aaaba')
s = s.replace('baBB', 'bb')
s = s.lower()
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"A",
"aaaba"
]
},
{
"method": "replace",
"args": [
"baBB",
"bb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bab') == 'BAAABAB'
assert candidate('aabaabba') == 'AAABAAAABABAAABAAAABBAAABA'
assert candidate('a') == 'AAABA'
assert candidate('bab') == 'BAAABAB'
assert candidate('ab... | 40 | [
{
"input": "bab",
"output": "BAAABAB"
},
{
"input": "aabaabba",
"output": "AAABAAAABABAAABAAAABBAAABA"
},
{
"input": "a",
"output": "AAABA"
},
{
"input": "bab",
"output": "BAAABAB"
},
{
"input": "abbab",
"output": "AAABBAAABAB"
},
{
"input": "b",
"... | [
{
"input": "a",
"output": "AAABA"
},
{
"input": "aaaaababbb",
"output": "AAABAAAABAAAABAAAABAAAABABAAABBB"
},
{
"input": "a",
"output": "AAABA"
},
{
"input": "ab",
"output": "AAABAB"
},
{
"input": "babbbaaab",
"output": "BAAABBBAAABAAAABAAAABAB"
},
{
"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000085 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbab') == 'ABBAB'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('baba') == 'BABA'
assert candidate('aabbbabb') == 'AABBBABB'
assert ... | 40 | [
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "aabbbabb",
"output": "AABBBABB"
},
{
"input": "baabab",
"output": "BAABAB"
},
{
... | [
{
"input": "abb",
"output": "ABB"
},
{
"input": "bbbaaaaba",
"output": "BBBAAAABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baabbaab",
"output": "BAABBAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"i... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000086 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bab', 'b')
return s
| [
{
"method": "replace",
"args": [
"bab",
"b"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababaa') == 'aabaa'
assert candidate('abaababaa') == 'abaabaa'
assert candidate('bb') == 'bb'
assert candidate('aabaaab') == 'aabaaab'
assert candidate('aaabaaabb') == '... | 40 | [
{
"input": "aababaa",
"output": "aabaa"
},
{
"input": "abaababaa",
"output": "abaabaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aabaaab",
"output": "aabaaab"
},
{
"input": "aaabaaabb",
"output": "aaabaaabb"
},
{
"input": "aaaba",
"output":... | [
{
"input": "ba",
"output": "ba"
},
{
"input": "abaababa",
"output": "abaaba"
},
{
"input": "aaaaaabbab",
"output": "aaaaaabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"i... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000087 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.lower()
s = s.replace('abaa', 'aba')
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abaa",
"aba"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabb') == 'aaabb'
assert candidate('bb') == 'bb'
assert candidate('bbbbaaab') == 'bbbbaaab'
assert candidate('baaa') == 'baaa'
assert candidate('babab') == 'babab'
a... | 40 | [
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbbbaaab",
"output": "bbbbaaab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "abbabababa",
"output": "abbababab... | [
{
"input": "aabbabba",
"output": "aabbabba"
},
{
"input": "aababaa",
"output": "aababa"
},
{
"input": "bbababaaba",
"output": "bbabababa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaaaaaabbb",
"output": "a... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000088 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BAAA', 'abbba')
s = s.upper()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAAA",
"abbba"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabbb') == 'AABBB'
assert candidate('a') == 'A'
assert candidate('bbb') == 'BBB'
assert candidate('baaaaaba') == 'ABBBAAABA'
assert candidate('bbabaaa') == 'BBAABBBA'
... | 40 | [
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "baaaaaba",
"output": "ABBBAAABA"
},
{
"input": "bbabaaa",
"output": "BBAABBBA"
},
{
"input": "aabbaabb",
"output": "AABBAABB"... | [
{
"input": "babaabb",
"output": "BABAABB"
},
{
"input": "abaabababb",
"output": "ABAABABABB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbaaaaaa",
"output": "BABBBAAAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabbbabb",
"output": "... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000089 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BA', 'bbab')
s = s.lower()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BA",
"bbab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababb') == 'aabbabbb'
assert candidate('ab') == 'ab'
assert candidate('aabaabab') == 'aabbababbabb'
assert candidate('b') == 'b'
assert candidate('babba') == 'bbabbbbab'... | 40 | [
{
"input": "aababb",
"output": "aabbabbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aabaabab",
"output": "aabbababbabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "babba",
"output": "bbabbbbab"
},
{
"input": "abbb",
"output": "abbb"
}... | [
{
"input": "ab",
"output": "ab"
},
{
"input": "bbbaab",
"output": "bbbbabab"
},
{
"input": "ba",
"output": "bbab"
},
{
"input": "abbaaa",
"output": "abbbabaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabaaa",
"output": "aabbabaa"
},
{
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000090 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('baa', 'ab')
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"baa",
"ab"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'baab'
assert candidate('bbaaaabba') == 'babaabba'
assert candidate('bbb') == 'bbb'
assert candidate('bbab') == 'bbab'
assert candidate('aaaaba') == 'aaaaba'
... | 40 | [
{
"input": "babaa",
"output": "baab"
},
{
"input": "bbaaaabba",
"output": "babaabba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaaaba",
"output": "aaaaba"
},
{
"input": "a",
"output": "a"
},
{
... | [
{
"input": "abaaabaa",
"output": "aabaab"
},
{
"input": "ababbababa",
"output": "ababbababa"
},
{
"input": "baa",
"output": "ab"
},
{
"input": "abaabaab",
"output": "aababb"
},
{
"input": "babbabb",
"output": "babbabb"
},
{
"input": "abbb",
"output... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000091 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abababa') == 'abababa'
assert candidate('ba') == 'ba'
assert candidate('bba') == 'bba'
assert candidate('aabbb') == 'aabbb'
assert candidate('a') == 'a'
assert candid... | 40 | [
{
"input": "abababa",
"output": "abababa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "ababaaa",
"output": "ababaaa"
},
{
"i... | [
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabbbbba",
"output": "bbabbbbba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaa"... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000092 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbb', 'bbbb')
s = s.upper()
s = s.replace('AABA', 'aabb')
s = s.upper()
return s
| [
{
"method": "replace",
"args": [
"bbb",
"bbbb"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AABA",
"aabb"
]
},
{
"method": "upper",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abba') == 'ABBA'
assert candidate('aaababb') == 'AAABBBB'
assert candidate('bbbbaaba') == 'BBBBBAABB'
assert candidate('a') == 'A'
assert candidate('babaabbb') == 'BABAAB... | 40 | [
{
"input": "abba",
"output": "ABBA"
},
{
"input": "aaababb",
"output": "AAABBBB"
},
{
"input": "bbbbaaba",
"output": "BBBBBAABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "babaabbb",
"output": "BABAABBBB"
},
{
"input": "aba",
"output": "ABA"
... | [
{
"input": "b",
"output": "B"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "abaaababa",
"output": "ABAAABBBA"
},
{
"input": "aabbabaa",
"output": "AABBABAA"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "bbbaabbb",
"output": "B... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000093 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bb', 'bbb')
s = s.lower()
s = s.upper()
s = s.replace('A', 'baaab')
return s
| [
{
"method": "replace",
"args": [
"bb",
"bbb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"A",
"baaab"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaa') == 'BBBbaaabbaaab'
assert candidate('aa') == 'baaabbaaab'
assert candidate('bbbaba') == 'BBBBbaaabBbaaab'
assert candidate('bbbbbaabaa') == 'BBBBBBBbaaabbaaabBbaaabbaa... | 40 | [
{
"input": "bbaa",
"output": "BBBbaaabbaaab"
},
{
"input": "aa",
"output": "baaabbaaab"
},
{
"input": "bbbaba",
"output": "BBBBbaaabBbaaab"
},
{
"input": "bbbbbaabaa",
"output": "BBBBBBBbaaabbaaabBbaaabbaaab"
},
{
"input": "ababababa",
"output": "baaabBbaaabBb... | [
{
"input": "bbbbabaaa",
"output": "BBBBBBbaaabBbaaabbaaabbaaab"
},
{
"input": "bbb",
"output": "BBBB"
},
{
"input": "aaaaaba",
"output": "baaabbaaabbaaabbaaabbaaabBbaaab"
},
{
"input": "baabbbbba",
"output": "BbaaabbaaabBBBBBBBbaaab"
},
{
"input": "aa",
"outpu... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000094 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('baaaa', 'bb')
s = s.lower()
return s
| [
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"baaaa",
"bb"
]
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abaa') == 'abaa'
assert candidate('bab') == 'bab'
assert candidate('abbaaa') == 'abbaaa'
assert candidate('abbbabab') == 'abbbabab'
assert candidate('baaabb') == 'baaabb'... | 40 | [
{
"input": "abaa",
"output": "abaa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abbaaa",
"output": "abbaaa"
},
{
"input": "abbbabab",
"output": "abbbabab"
},
{
"input": "baaabb",
"output": "baaabb"
},
{
"input": "baabb",
"output": "baabb"
... | [
{
"input": "aaabaa",
"output": "aaabaa"
},
{
"input": "baaaaab",
"output": "bbab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbaaaa",
"output": "bbbb"
},
{
"input": "ababab",
"output": "ababab"
},
{
"input": "bbbbabab",
"output": "bbbbabab"
... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000095 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('abaab', 'aaaab')
s = s.lower()
s = s.lower()
s = s.replace('aabb', 'babaa')
return s
| [
{
"method": "replace",
"args": [
"abaab",
"aaaab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"aabb",
"babaa"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'b'
assert candidate('bbaabbaba') == 'bbbabaaaba'
assert candidate('baabaaa') == 'baabaaa'
assert candidate('abbabaabbb') == 'abbaababaab'
assert candidate('aabbb'... | 40 | [
{
"input": "b",
"output": "b"
},
{
"input": "bbaabbaba",
"output": "bbbabaaaba"
},
{
"input": "baabaaa",
"output": "baabaaa"
},
{
"input": "abbabaabbb",
"output": "abbaababaab"
},
{
"input": "aabbb",
"output": "babaab"
},
{
"input": "baab",
"output... | [
{
"input": "baabbababa",
"output": "bbabaaababa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aabbbbb",
"output": "babaabbb"
},
{
"input": "aabaabbbbb",
"output": "aaababaabbb"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "bab",
"o... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000096 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('b', 'aaaba')
s = s.upper()
s = s.replace('AAAB', 'b')
return s
| [
{
"method": "replace",
"args": [
"b",
"aaaba"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AAAB",
"b"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baabbaaaa') == 'bAAAbAbAAAAA'
assert candidate('baaaaaab') == 'bAAAAAAAbA'
assert candidate('baaabab') == 'bAAAAbAAbA'
assert candidate('a') == 'A'
assert candidate('abab... | 40 | [
{
"input": "baabbaaaa",
"output": "bAAAbAbAAAAA"
},
{
"input": "baaaaaab",
"output": "bAAAAAAAbA"
},
{
"input": "baaabab",
"output": "bAAAAbAAbA"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababaab",
"output": "AbAAbAAAbA"
},
{
"input": "baababba",... | [
{
"input": "baaaba",
"output": "bAAAAbAA"
},
{
"input": "ab",
"output": "AbA"
},
{
"input": "bb",
"output": "bAbA"
},
{
"input": "baabbaaba",
"output": "bAAAbAbAAAbAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbbabbbb",
"output": "bAbAbAbAA... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000097 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.upper()
s = s.replace('AAABA', 'a')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AAABA",
"a"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('bbab') == 'BBAB'
assert candidate('aababa') == 'AABABA'
assert candidate('bbbabb') == 'BBBABB'
assert candidate('aba') == 'ABA'
assert ca... | 40 | [
{
"input": "b",
"output": "B"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "aababa",
"output": "AABABA"
},
{
"input": "bbbabb",
"output": "BBBABB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "baaababba",
"output": "BaBBA"
},
{
... | [
{
"input": "aababa",
"output": "AABABA"
},
{
"input": "abbabba",
"output": "ABBABBA"
},
{
"input": "babba",
"output": "BABBA"
},
{
"input": "bbaabba",
"output": "BBAABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaaa",
"output": "BBAAA"
}... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000098 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.replace('aaaaa', 'a')
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"aaaaa",
"a"
]
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabbba') == 'aaabbba'
assert candidate('baabba') == 'baabba'
assert candidate('a') == 'a'
assert candidate('babbbaaaba') == 'babbbaaaba'
assert candidate('bbb') == 'bbb'... | 40 | [
{
"input": "aaabbba",
"output": "aaabbba"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "babbbaaaba",
"output": "babbbaaaba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "a",
"output": "a"
},
{
... | [
{
"input": "bbbbbbbab",
"output": "bbbbbbbab"
},
{
"input": "bbbbabbbb",
"output": "bbbbabbbb"
},
{
"input": "abbbaaaaa",
"output": "abbba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bbaabbb",
"output": "bbaabbb"
},
{
"input": "bbb",
"outp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
pbe-world/000099 | apply_pipeline | from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
... | def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
return s
| [
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] | from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baa') == 'baa'
assert candidate('bbba') == 'bbba'
assert candidate('b') == 'b'
assert candidate('baba') == 'baba'
assert candidate('aababa') == 'aababa'
assert candid... | 40 | [
{
"input": "baa",
"output": "baa"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "b",
"output": "b"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "aababa",
"output": "aababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
... | [
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabaaba",
"output": "aabaaba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abababaa",
"output": "abababaa"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"inp... | {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.