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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('baaaaaaaba') == 'BAAAAAAABA'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('aababbaab') == 'AABABBAAB'
>>> apply_pipeline('bbabbabab') == 'BBABBABAB'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('aaabb') == 'AAABB'
"""
raise NotImplementedError()
|
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'
assert candidate('bbabbabab') == 'BBABBABAB'
assert candidate('ba') == 'BA'
assert candidate('aaabb') == 'AAABB'
# hidden tests
assert candidate('aaa') == 'AAA'
assert candidate('aaaabbb') == 'AAAABBB'
assert candidate('babb') == 'BABB'
assert candidate('bbb') == 'BBB'
assert candidate('ab') == 'AB'
assert candidate('aaababaabb') == 'AAABABAABB'
assert candidate('bba') == 'BBA'
assert candidate('baabaaabb') == 'BAABAAABB'
assert candidate('ababbbaabb') == 'ABABBBAABB'
assert candidate('a') == 'A'
assert candidate('ababba') == 'ABABBA'
assert candidate('aa') == 'AA'
assert candidate('ababaabba') == 'ABABAABBA'
assert candidate('aaabba') == 'AAABBA'
assert candidate('aaba') == 'AABA'
assert candidate('bba') == 'BBA'
assert candidate('aabab') == 'AABAB'
assert candidate('abbb') == 'ABBB'
assert candidate('aaab') == 'AAAB'
assert candidate('babbbb') == 'BABBBB'
assert candidate('a') == 'A'
assert candidate('abaab') == 'ABAAB'
assert candidate('bbabab') == 'BBABAB'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('babbab') == 'BABBAB'
assert candidate('bbbbbaabb') == 'BBBBBAABB'
assert candidate('bba') == 'BBA'
assert candidate('babbb') == 'BABBB'
assert candidate('babaabba') == 'BABAABBA'
assert candidate('baaa') == 'BAAA'
assert candidate('a') == '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": "ba",
"output": "BA"
},
{
"input": "aaabb",
"output": "AAABB"
}
] |
[
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaaabbb",
"output": "AAAABBB"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaababaabb",
"output": "AAABABAABB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "baabaaabb",
"output": "BAABAAABB"
},
{
"input": "ababbbaabb",
"output": "ABABBBAABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababba",
"output": "ABABBA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "ababaabba",
"output": "ABABAABBA"
},
{
"input": "aaabba",
"output": "AAABBA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "aabab",
"output": "AABAB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "babbbb",
"output": "BABBBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaab",
"output": "ABAAB"
},
{
"input": "bbabab",
"output": "BBABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbab",
"output": "BABBAB"
},
{
"input": "bbbbbaabb",
"output": "BBBBBAABB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "babbb",
"output": "BABBB"
},
{
"input": "babaabba",
"output": "BABAABBA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"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/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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbbaaba') == 'abbbaaba'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('bbaba') == 'bbaba'
>>> apply_pipeline('bbabbaba') == 'bbabbaba'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('ababbbaa') == 'ababbbaa'
>>> apply_pipeline('aaabaabbba') == 'aaabaabbba'
>>> apply_pipeline('bbabb') == 'bbabb'
"""
raise NotImplementedError()
|
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'
assert candidate('ababbbaa') == 'ababbbaa'
assert candidate('aaabaabbba') == 'aaabaabbba'
assert candidate('bbabb') == 'bbabb'
# hidden tests
assert candidate('aba') == 'aba'
assert candidate('abab') == 'abab'
assert candidate('bbbbaaaa') == 'bbbbaaaa'
assert candidate('aaaaa') == 'aaaaa'
assert candidate('abb') == 'abb'
assert candidate('bbaabbbaab') == 'bbaabbbaab'
assert candidate('abaaabaaaa') == 'abaaabaaaa'
assert candidate('bbabb') == 'bbabb'
assert candidate('bbbaabb') == 'bbbaabb'
assert candidate('baaaabaabb') == 'baaaabaabb'
assert candidate('abbab') == 'abbab'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('bbbabab') == 'bbbabab'
assert candidate('babab') == 'babab'
assert candidate('aabbbaa') == 'aabbbaa'
assert candidate('abbba') == 'abbba'
assert candidate('a') == 'a'
assert candidate('bab') == 'bab'
assert candidate('aa') == 'aa'
assert candidate('aabbbbbb') == 'aabbbbbb'
assert candidate('baba') == 'baba'
assert candidate('aabbbbabbb') == 'aabbbbabbb'
assert candidate('bbb') == 'bbb'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('babb') == 'babb'
assert candidate('babaaba') == 'babaaba'
assert candidate('abaabaab') == 'abaabaab'
assert candidate('bbabb') == 'bbabb'
assert candidate('baaaba') == 'baaaba'
assert candidate('ba') == 'ba'
assert candidate('ba') == 'ba'
assert candidate('aabab') == 'aabab'
| 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": "aaabaabbba",
"output": "aaabaabbba"
},
{
"input": "bbabb",
"output": "bbabb"
}
] |
[
{
"input": "aba",
"output": "aba"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "bbbbaaaa",
"output": "bbbbaaaa"
},
{
"input": "aaaaa",
"output": "aaaaa"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbaabbbaab",
"output": "bbaabbbaab"
},
{
"input": "abaaabaaaa",
"output": "abaaabaaaa"
},
{
"input": "bbabb",
"output": "bbabb"
},
{
"input": "bbbaabb",
"output": "bbbaabb"
},
{
"input": "baaaabaabb",
"output": "baaaabaabb"
},
{
"input": "abbab",
"output": "abbab"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "bbbabab",
"output": "bbbabab"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "aabbbaa",
"output": "aabbbaa"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "a",
"output": "a"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabbbbbb",
"output": "aabbbbbb"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "aabbbbabbb",
"output": "aabbbbabbb"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "babaaba",
"output": "babaaba"
},
{
"input": "abaabaab",
"output": "abaabaab"
},
{
"input": "bbabb",
"output": "bbabb"
},
{
"input": "baaaba",
"output": "baaaba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aabab",
"output": "aabab"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbaaba') == 'bbaaba'
>>> apply_pipeline('baab') == 'baab'
>>> apply_pipeline('bbbb') == 'bbbb'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('aabba') == 'aabba'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('aa') == 'aa'
>>> apply_pipeline('b') == 'b'
"""
raise NotImplementedError()
|
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 candidate('bb') == 'bb'
assert candidate('aa') == 'aa'
assert candidate('b') == 'b'
# hidden tests
assert candidate('abbbbba') == 'abbbbba'
assert candidate('aaaababa') == 'aaaababa'
assert candidate('ababbbabb') == 'ababbbabb'
assert candidate('aaabaa') == 'aaabaa'
assert candidate('bababa') == 'bababa'
assert candidate('baabbbbaaa') == 'baabbbbaaa'
assert candidate('baaaaabbbb') == 'baaaaabbbb'
assert candidate('bbb') == 'bbb'
assert candidate('aaaaaabbbb') == 'aaaaaabbbb'
assert candidate('bbbaabbabb') == 'bbbaabbabb'
assert candidate('baabaaaba') == 'baabaaaba'
assert candidate('bbb') == 'bbb'
assert candidate('ab') == 'ab'
assert candidate('aababab') == 'aababab'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('bb') == 'bb'
assert candidate('bbbabababb') == 'bbbabababb'
assert candidate('ba') == 'ba'
assert candidate('bbab') == 'bbab'
assert candidate('babaa') == 'babaa'
assert candidate('aabbaaaab') == 'aabbaaaab'
assert candidate('aaaa') == 'aaaa'
assert candidate('bbbbabab') == 'bbbbabab'
assert candidate('bbababbb') == 'bbababbb'
assert candidate('a') == 'a'
assert candidate('baabba') == 'baabba'
assert candidate('abbaabab') == 'abbaabab'
assert candidate('aa') == 'aa'
assert candidate('bbab') == 'bbab'
assert candidate('bbbbab') == 'bbbbab'
assert candidate('ba') == 'ba'
| 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": "aa",
"output": "aa"
},
{
"input": "b",
"output": "b"
}
] |
[
{
"input": "abbbbba",
"output": "abbbbba"
},
{
"input": "aaaababa",
"output": "aaaababa"
},
{
"input": "ababbbabb",
"output": "ababbbabb"
},
{
"input": "aaabaa",
"output": "aaabaa"
},
{
"input": "bababa",
"output": "bababa"
},
{
"input": "baabbbbaaa",
"output": "baabbbbaaa"
},
{
"input": "baaaaabbbb",
"output": "baaaaabbbb"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "aaaaaabbbb",
"output": "aaaaaabbbb"
},
{
"input": "bbbaabbabb",
"output": "bbbaabbabb"
},
{
"input": "baabaaaba",
"output": "baabaaaba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aababab",
"output": "aababab"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbbabababb",
"output": "bbbabababb"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "babaa",
"output": "babaa"
},
{
"input": "aabbaaaab",
"output": "aabbaaaab"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "bbbbabab",
"output": "bbbbabab"
},
{
"input": "bbababbb",
"output": "bbababbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "abbaabab",
"output": "abbaabab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "bbbbab",
"output": "bbbbab"
},
{
"input": "ba",
"output": "ba"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('baaabaab') == 'baaaabbaaaaaaa'
>>> apply_pipeline('bbbaa') == 'baaabaaabaaaAA'
>>> apply_pipeline('aaabbababa') == 'AaaaabaaaAbaaaAbaaaA'
>>> apply_pipeline('bbaabbbbb') == 'baaabaaaaaaabaaabaaabaaabaaa'
>>> apply_pipeline('b') == 'baaa'
>>> apply_pipeline('bbbababa') == 'baaabaaabaaaAbaaaAbaaaA'
>>> apply_pipeline('bbab') == 'baaabaaaAbaaa'
>>> apply_pipeline('bbbbba') == 'baaabaaabaaabaaabaaaA'
"""
raise NotImplementedError()
|
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') == 'baaabaaaaaaabaaabaaabaaabaaa'
assert candidate('b') == 'baaa'
assert candidate('bbbababa') == 'baaabaaabaaaAbaaaAbaaaA'
assert candidate('bbab') == 'baaabaaaAbaaa'
assert candidate('bbbbba') == 'baaabaaabaaabaaabaaaA'
# hidden tests
assert candidate('ba') == 'baaaA'
assert candidate('abbabbaa') == 'AbaaabaaaAbaaabaaaAA'
assert candidate('aaaaab') == 'AAAaaaa'
assert candidate('b') == 'baaa'
assert candidate('bbaaabbbb') == 'baaabaaaabbaaabaaabaaabaaa'
assert candidate('aababbb') == 'aaaaAbaaabaaabaaa'
assert candidate('aab') == 'aaaa'
assert candidate('aaabaabab') == 'AaaaaaaaaAbaaa'
assert candidate('babababaa') == 'baaaAbaaaAbaaaAbaaaAA'
assert candidate('aabaaaabab') == 'aaaaAAaaaaAbaaa'
assert candidate('abbbbabbba') == 'AbaaabaaabaaabaaaAbaaabaaabaaaA'
assert candidate('a') == 'A'
assert candidate('bbbababb') == 'baaabaaabaaaAbaaaAbaaabaaa'
assert candidate('bababa') == 'baaaAbaaaAbaaaA'
assert candidate('abbaaaab') == 'AbaaabaaaAAaaaa'
assert candidate('baabbaa') == 'baaaaaaabaaaAA'
assert candidate('bbbbaabb') == 'baaabaaabaaabaaaaaaabaaa'
assert candidate('abaa') == 'AbaaaAA'
assert candidate('bbbaa') == 'baaabaaabaaaAA'
assert candidate('abbbbab') == 'AbaaabaaabaaabaaaAbaaa'
assert candidate('a') == 'A'
assert candidate('babbba') == 'baaaAbaaabaaabaaaA'
assert candidate('abb') == 'Abaaabaaa'
assert candidate('baabaa') == 'baaaaaaaAA'
assert candidate('a') == 'A'
assert candidate('bbaabb') == 'baaabaaaaaaabaaa'
assert candidate('bbb') == 'baaabaaabaaa'
assert candidate('bbbabbabb') == 'baaabaaabaaaAbaaabaaaAbaaabaaa'
assert candidate('b') == 'baaa'
assert candidate('aabab') == 'aaaaAbaaa'
assert candidate('aaa') == 'AAA'
assert candidate('abbb') == 'Abaaabaaabaaa'
| 40
|
[
{
"input": "baaabaab",
"output": "baaaabbaaaaaaa"
},
{
"input": "bbbaa",
"output": "baaabaaabaaaAA"
},
{
"input": "aaabbababa",
"output": "AaaaabaaaAbaaaAbaaaA"
},
{
"input": "bbaabbbbb",
"output": "baaabaaaaaaabaaabaaabaaabaaa"
},
{
"input": "b",
"output": "baaa"
},
{
"input": "bbbababa",
"output": "baaabaaabaaaAbaaaAbaaaA"
},
{
"input": "bbab",
"output": "baaabaaaAbaaa"
},
{
"input": "bbbbba",
"output": "baaabaaabaaabaaabaaaA"
}
] |
[
{
"input": "ba",
"output": "baaaA"
},
{
"input": "abbabbaa",
"output": "AbaaabaaaAbaaabaaaAA"
},
{
"input": "aaaaab",
"output": "AAAaaaa"
},
{
"input": "b",
"output": "baaa"
},
{
"input": "bbaaabbbb",
"output": "baaabaaaabbaaabaaabaaabaaa"
},
{
"input": "aababbb",
"output": "aaaaAbaaabaaabaaa"
},
{
"input": "aab",
"output": "aaaa"
},
{
"input": "aaabaabab",
"output": "AaaaaaaaaAbaaa"
},
{
"input": "babababaa",
"output": "baaaAbaaaAbaaaAbaaaAA"
},
{
"input": "aabaaaabab",
"output": "aaaaAAaaaaAbaaa"
},
{
"input": "abbbbabbba",
"output": "AbaaabaaabaaabaaaAbaaabaaabaaaA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbababb",
"output": "baaabaaabaaaAbaaaAbaaabaaa"
},
{
"input": "bababa",
"output": "baaaAbaaaAbaaaA"
},
{
"input": "abbaaaab",
"output": "AbaaabaaaAAaaaa"
},
{
"input": "baabbaa",
"output": "baaaaaaabaaaAA"
},
{
"input": "bbbbaabb",
"output": "baaabaaabaaabaaaaaaabaaa"
},
{
"input": "abaa",
"output": "AbaaaAA"
},
{
"input": "bbbaa",
"output": "baaabaaabaaaAA"
},
{
"input": "abbbbab",
"output": "AbaaabaaabaaabaaaAbaaa"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbba",
"output": "baaaAbaaabaaabaaaA"
},
{
"input": "abb",
"output": "Abaaabaaa"
},
{
"input": "baabaa",
"output": "baaaaaaaAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbaabb",
"output": "baaabaaaaaaabaaa"
},
{
"input": "bbb",
"output": "baaabaaabaaa"
},
{
"input": "bbbabbabb",
"output": "baaabaaabaaaAbaaabaaaAbaaabaaa"
},
{
"input": "b",
"output": "baaa"
},
{
"input": "aabab",
"output": "aaaaAbaaa"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "abbb",
"output": "Abaaabaaabaaa"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abb') == 'AB'
>>> apply_pipeline('bababab') == 'AAA'
>>> apply_pipeline('bbbbaabb') == 'BBBBAAB'
>>> apply_pipeline('abba') == 'ABA'
>>> apply_pipeline('aabbbbb') == 'AABBBB'
>>> apply_pipeline('bbbabbaa') == 'BBBABAA'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('aabba') == 'AABA'
"""
raise NotImplementedError()
|
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'
assert candidate('bbbabbaa') == 'BBBABAA'
assert candidate('aa') == 'AA'
assert candidate('aabba') == 'AABA'
# hidden tests
assert candidate('baaaaba') == 'BAAAAA'
assert candidate('bbabaabbba') == 'BBAAABBA'
assert candidate('abbabbbbb') == 'ABABBBB'
assert candidate('bba') == 'BBA'
assert candidate('baabababb') == 'BAAAAB'
assert candidate('ababababb') == 'AAAAB'
assert candidate('aa') == 'AA'
assert candidate('baaaa') == 'BAAAA'
assert candidate('abbaaaab') == 'ABAAAA'
assert candidate('abab') == 'AA'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('bbabba') == 'BBABA'
assert candidate('bbaaaa') == 'BBAAAA'
assert candidate('bbaab') == 'BBAA'
assert candidate('babb') == 'BAB'
assert candidate('bbbab') == 'BBBA'
assert candidate('aba') == 'AA'
assert candidate('aaaaabaaa') == 'AAAAAAAA'
assert candidate('aab') == 'AA'
assert candidate('abbaab') == 'ABAA'
assert candidate('a') == 'A'
assert candidate('bbabaaaaa') == 'BBAAAAAA'
assert candidate('bbbb') == 'BBBB'
assert candidate('bb') == 'BB'
assert candidate('aabaaabb') == 'AAAAAB'
assert candidate('baaaabb') == 'BAAAAB'
assert candidate('aaaabb') == 'AAAAB'
assert candidate('a') == 'A'
assert candidate('aabaa') == 'AAAA'
assert candidate('ababaabbba') == 'AAAABBA'
assert candidate('ba') == 'BA'
assert candidate('ba') == 'BA'
| 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": "aa",
"output": "AA"
},
{
"input": "aabba",
"output": "AABA"
}
] |
[
{
"input": "baaaaba",
"output": "BAAAAA"
},
{
"input": "bbabaabbba",
"output": "BBAAABBA"
},
{
"input": "abbabbbbb",
"output": "ABABBBB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "baabababb",
"output": "BAAAAB"
},
{
"input": "ababababb",
"output": "AAAAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "abbaaaab",
"output": "ABAAAA"
},
{
"input": "abab",
"output": "AA"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "bbabba",
"output": "BBABA"
},
{
"input": "bbaaaa",
"output": "BBAAAA"
},
{
"input": "bbaab",
"output": "BBAA"
},
{
"input": "babb",
"output": "BAB"
},
{
"input": "bbbab",
"output": "BBBA"
},
{
"input": "aba",
"output": "AA"
},
{
"input": "aaaaabaaa",
"output": "AAAAAAAA"
},
{
"input": "aab",
"output": "AA"
},
{
"input": "abbaab",
"output": "ABAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbabaaaaa",
"output": "BBAAAAAA"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabaaabb",
"output": "AAAAAB"
},
{
"input": "baaaabb",
"output": "BAAAAB"
},
{
"input": "aaaabb",
"output": "AAAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabaa",
"output": "AAAA"
},
{
"input": "ababaabbba",
"output": "AAAABBA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ba",
"output": "BA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('baaababb') == 'BAAABABB'
>>> apply_pipeline('baabbba') == 'BABBAA'
>>> apply_pipeline('bbbaa') == 'BBBAA'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('abbbab') == 'BBAAB'
>>> apply_pipeline('ababb') == 'ABABB'
>>> apply_pipeline('baaabaa') == 'BAAABAA'
>>> apply_pipeline('bbb') == 'BBB'
"""
raise NotImplementedError()
|
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'
assert candidate('ababb') == 'ABABB'
assert candidate('baaabaa') == 'BAAABAA'
assert candidate('bbb') == 'BBB'
# hidden tests
assert candidate('bbbbaaa') == 'BBBBAAA'
assert candidate('baba') == 'BABA'
assert candidate('babbaabba') == 'BABBAABBA'
assert candidate('abaababb') == 'ABAABABB'
assert candidate('abaaab') == 'ABAAAB'
assert candidate('baaaaabbab') == 'BAAAAABBAB'
assert candidate('bbaab') == 'BBAAB'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('abbabb') == 'ABBABB'
assert candidate('baabbbb') == 'BABBAB'
assert candidate('baabbaba') == 'BAABBABA'
assert candidate('abbbbba') == 'BBABBA'
assert candidate('bbaaabaaab') == 'BBAAABAAAB'
assert candidate('abaababa') == 'ABAABABA'
assert candidate('babaab') == 'BABAAB'
assert candidate('abaaa') == 'ABAAA'
assert candidate('baaa') == 'BAAA'
assert candidate('baabababa') == 'BAABABABA'
assert candidate('baaa') == 'BAAA'
assert candidate('bbabaa') == 'BBABAA'
assert candidate('aa') == 'AA'
assert candidate('baabbaaa') == 'BAABBAAA'
assert candidate('abb') == 'ABB'
assert candidate('baabaab') == 'BAABAAB'
assert candidate('b') == 'B'
assert candidate('abba') == 'ABBA'
assert candidate('bbaa') == 'BBAA'
assert candidate('aabbabbb') == 'AABBBBA'
assert candidate('abaaaabaa') == 'ABAAAABAA'
assert candidate('b') == 'B'
assert candidate('bbbbaabab') == 'BBBBAABAB'
| 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": "baaabaa",
"output": "BAAABAA"
},
{
"input": "bbb",
"output": "BBB"
}
] |
[
{
"input": "bbbbaaa",
"output": "BBBBAAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "babbaabba",
"output": "BABBAABBA"
},
{
"input": "abaababb",
"output": "ABAABABB"
},
{
"input": "abaaab",
"output": "ABAAAB"
},
{
"input": "baaaaabbab",
"output": "BAAAAABBAB"
},
{
"input": "bbaab",
"output": "BBAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "abbabb",
"output": "ABBABB"
},
{
"input": "baabbbb",
"output": "BABBAB"
},
{
"input": "baabbaba",
"output": "BAABBABA"
},
{
"input": "abbbbba",
"output": "BBABBA"
},
{
"input": "bbaaabaaab",
"output": "BBAAABAAAB"
},
{
"input": "abaababa",
"output": "ABAABABA"
},
{
"input": "babaab",
"output": "BABAAB"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "baabababa",
"output": "BAABABABA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "bbabaa",
"output": "BBABAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baabbaaa",
"output": "BAABBAAA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "baabaab",
"output": "BAABAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "aabbabbb",
"output": "AABBBBA"
},
{
"input": "abaaaabaa",
"output": "ABAAAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbbaabab",
"output": "BBBBAABAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbab') == 'bbab'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('bbaaaa') == 'bbaaaa'
>>> apply_pipeline('aaa') == 'aaa'
>>> apply_pipeline('ababaaaaaa') == 'ababaaaaaa'
>>> apply_pipeline('babb') == 'babb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('baaaabaaba') == 'baaaabaaba'
"""
raise NotImplementedError()
|
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'
assert candidate('babb') == 'babb'
assert candidate('b') == 'b'
assert candidate('baaaabaaba') == 'baaaabaaba'
# hidden tests
assert candidate('bbbaa') == 'bbbaa'
assert candidate('babaa') == 'babaa'
assert candidate('abbbbbbbb') == 'abbbbbbbb'
assert candidate('aba') == 'aba'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('baaaaabaa') == 'baaaaabaa'
assert candidate('bbaaabbaba') == 'bbaaabbaba'
assert candidate('abbabaaaaa') == 'abbabaaaaa'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('aababaaaaa') == 'aababaaaaa'
assert candidate('babbabbba') == 'babbabbba'
assert candidate('bbb') == 'bbb'
assert candidate('baa') == 'baa'
assert candidate('bbaaaba') == 'bbaaaba'
assert candidate('baa') == 'baa'
assert candidate('abaabbaa') == 'abaabbaa'
assert candidate('babaaa') == 'babaaa'
assert candidate('baaabb') == 'baaabb'
assert candidate('abbbbba') == 'abbbbba'
assert candidate('aabaabab') == 'aabaabab'
assert candidate('aabab') == 'aabab'
assert candidate('aab') == 'aab'
assert candidate('bababaaaba') == 'bababaaaba'
assert candidate('bbbb') == 'bbbb'
assert candidate('aabb') == 'aabb'
assert candidate('aba') == 'aba'
assert candidate('abbaaaa') == 'abbaaaa'
assert candidate('bab') == 'bab'
assert candidate('bb') == 'bb'
assert candidate('bbababbb') == 'bbababbb'
| 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": "b",
"output": "b"
},
{
"input": "baaaabaaba",
"output": "baaaabaaba"
}
] |
[
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "babaa",
"output": "babaa"
},
{
"input": "abbbbbbbb",
"output": "abbbbbbbb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaaaabaa",
"output": "baaaaabaa"
},
{
"input": "bbaaabbaba",
"output": "bbaaabbaba"
},
{
"input": "abbabaaaaa",
"output": "abbabaaaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "aababaaaaa",
"output": "aababaaaaa"
},
{
"input": "babbabbba",
"output": "babbabbba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bbaaaba",
"output": "bbaaaba"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "abaabbaa",
"output": "abaabbaa"
},
{
"input": "babaaa",
"output": "babaaa"
},
{
"input": "baaabb",
"output": "baaabb"
},
{
"input": "abbbbba",
"output": "abbbbba"
},
{
"input": "aabaabab",
"output": "aabaabab"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bababaaaba",
"output": "bababaaaba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "abbaaaa",
"output": "abbaaaa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbababbb",
"output": "bbababbb"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bab') == 'BAB'
>>> apply_pipeline('abbabaaaba') == 'ABBAABABAAABA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('bbbb') == 'BBAABBBAAB'
>>> apply_pipeline('aaaabbaaba') == 'AAAABBAABAABA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bbbbba') == 'BBAABBBAABBA'
>>> apply_pipeline('aaab') == 'AAAB'
"""
raise NotImplementedError()
|
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') == 'AAAABBAABAABA'
assert candidate('b') == 'B'
assert candidate('bbbbba') == 'BBAABBBAABBA'
assert candidate('aaab') == 'AAAB'
# hidden tests
assert candidate('ab') == 'AB'
assert candidate('bbbb') == 'BBAABBBAAB'
assert candidate('bbaba') == 'BBAABABA'
assert candidate('abaabbbaaa') == 'ABAABBAABBAAA'
assert candidate('bbba') == 'BBAABBA'
assert candidate('aabbab') == 'AABBAABAB'
assert candidate('a') == 'A'
assert candidate('baaabaab') == 'BAAABAAB'
assert candidate('bbbbaaa') == 'BBAABBBAABAAA'
assert candidate('abaaaa') == 'ABAAAA'
assert candidate('bbaa') == 'BBAABAA'
assert candidate('baaabbb') == 'BAAABBAABB'
assert candidate('bbabbbaab') == 'BBAABABBAABBAAB'
assert candidate('a') == 'A'
assert candidate('aaaa') == 'AAAA'
assert candidate('ba') == 'BA'
assert candidate('baaaaaa') == 'BAAAAAA'
assert candidate('bbabbaa') == 'BBAABABBAABAA'
assert candidate('b') == 'B'
assert candidate('ababaab') == 'ABABAAB'
assert candidate('ab') == 'AB'
assert candidate('abab') == 'ABAB'
assert candidate('baababb') == 'BAABABBAAB'
assert candidate('aaaa') == 'AAAA'
assert candidate('baaaababbb') == 'BAAAABABBAABB'
assert candidate('aaaabbbb') == 'AAAABBAABBBAAB'
assert candidate('aa') == 'AA'
assert candidate('a') == 'A'
assert candidate('bbb') == 'BBAABB'
assert candidate('babbaabbbb') == 'BABBAABAABBAABBBAAB'
assert candidate('bbaaaaa') == 'BBAABAAAAA'
assert candidate('bb') == 'BBAAB'
| 40
|
[
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbabaaaba",
"output": "ABBAABABAAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbb",
"output": "BBAABBBAAB"
},
{
"input": "aaaabbaaba",
"output": "AAAABBAABAABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbbba",
"output": "BBAABBBAABBA"
},
{
"input": "aaab",
"output": "AAAB"
}
] |
[
{
"input": "ab",
"output": "AB"
},
{
"input": "bbbb",
"output": "BBAABBBAAB"
},
{
"input": "bbaba",
"output": "BBAABABA"
},
{
"input": "abaabbbaaa",
"output": "ABAABBAABBAAA"
},
{
"input": "bbba",
"output": "BBAABBA"
},
{
"input": "aabbab",
"output": "AABBAABAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaabaab",
"output": "BAAABAAB"
},
{
"input": "bbbbaaa",
"output": "BBAABBBAABAAA"
},
{
"input": "abaaaa",
"output": "ABAAAA"
},
{
"input": "bbaa",
"output": "BBAABAA"
},
{
"input": "baaabbb",
"output": "BAAABBAABB"
},
{
"input": "bbabbbaab",
"output": "BBAABABBAABBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baaaaaa",
"output": "BAAAAAA"
},
{
"input": "bbabbaa",
"output": "BBAABABBAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ababaab",
"output": "ABABAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "baababb",
"output": "BAABABBAAB"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "baaaababbb",
"output": "BAAAABABBAABB"
},
{
"input": "aaaabbbb",
"output": "AAAABBAABBBAAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbb",
"output": "BBAABB"
},
{
"input": "babbaabbbb",
"output": "BABBAABAABBAABBBAAB"
},
{
"input": "bbaaaaa",
"output": "BBAABAAAAA"
},
{
"input": "bb",
"output": "BBAAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbaa') == 'bbaa'
>>> apply_pipeline('bbbbaa') == 'bbbbaa'
>>> apply_pipeline('aabbaba') == 'aaaaba'
>>> apply_pipeline('baba') == 'baba'
>>> apply_pipeline('abababbbba') == 'abababbbba'
>>> apply_pipeline('abbbaaa') == 'abbbaaa'
>>> apply_pipeline('bbbbaaaa') == 'bbbbaaaa'
>>> apply_pipeline('baaba') == 'baaba'
"""
raise NotImplementedError()
|
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') == 'abababbbba'
assert candidate('abbbaaa') == 'abbbaaa'
assert candidate('bbbbaaaa') == 'bbbbaaaa'
assert candidate('baaba') == 'baaba'
# hidden tests
assert candidate('abaaa') == 'abaaa'
assert candidate('aaaabaaba') == 'aaaabaaba'
assert candidate('abb') == 'abb'
assert candidate('a') == 'a'
assert candidate('aa') == 'aa'
assert candidate('aabbb') == 'aabbb'
assert candidate('bbbabaaa') == 'baabaaa'
assert candidate('aababbabbb') == 'aabaaabbb'
assert candidate('abaaabb') == 'abaaabb'
assert candidate('bba') == 'bba'
assert candidate('aaaababab') == 'aaaababab'
assert candidate('baaa') == 'baaa'
assert candidate('baaa') == 'baaa'
assert candidate('abababaabb') == 'abababaabb'
assert candidate('aaabaa') == 'aaabaa'
assert candidate('bbbbab') == 'bbaab'
assert candidate('baabaa') == 'baabaa'
assert candidate('bbabbbb') == 'aabbbb'
assert candidate('bbaaab') == 'bbaaab'
assert candidate('aba') == 'aba'
assert candidate('aa') == 'aa'
assert candidate('baabbabbab') == 'baaaabbab'
assert candidate('bab') == 'bab'
assert candidate('aaaaba') == 'aaaaba'
assert candidate('abb') == 'abb'
assert candidate('a') == 'a'
assert candidate('aabbaaab') == 'aabbaaab'
assert candidate('bbaabab') == 'bbaabab'
assert candidate('abbba') == 'abbba'
assert candidate('bbabbbbba') == 'aabbbbba'
assert candidate('abaaabaaa') == 'abaaabaaa'
assert candidate('baa') == 'baa'
| 40
|
[
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "aabbaba",
"output": "aaaaba"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "abababbbba",
"output": "abababbbba"
},
{
"input": "abbbaaa",
"output": "abbbaaa"
},
{
"input": "bbbbaaaa",
"output": "bbbbaaaa"
},
{
"input": "baaba",
"output": "baaba"
}
] |
[
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "aaaabaaba",
"output": "aaaabaaba"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"input": "bbbabaaa",
"output": "baabaaa"
},
{
"input": "aababbabbb",
"output": "aabaaabbb"
},
{
"input": "abaaabb",
"output": "abaaabb"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aaaababab",
"output": "aaaababab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "abababaabb",
"output": "abababaabb"
},
{
"input": "aaabaa",
"output": "aaabaa"
},
{
"input": "bbbbab",
"output": "bbaab"
},
{
"input": "baabaa",
"output": "baabaa"
},
{
"input": "bbabbbb",
"output": "aabbbb"
},
{
"input": "bbaaab",
"output": "bbaaab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "baabbabbab",
"output": "baaaabbab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aaaaba",
"output": "aaaaba"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabbaaab",
"output": "aabbaaab"
},
{
"input": "bbaabab",
"output": "bbaabab"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "bbabbbbba",
"output": "aabbbbba"
},
{
"input": "abaaabaaa",
"output": "abaaabaaa"
},
{
"input": "baa",
"output": "baa"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('baaabaaab') == 'baaabaaab'
>>> apply_pipeline('aab') == 'aab'
>>> apply_pipeline('abbbbb') == 'abbbbb'
>>> apply_pipeline('aabaaaabbb') == 'aabaaaabbb'
>>> apply_pipeline('baabba') == 'baabba'
>>> apply_pipeline('bba') == 'bba'
>>> apply_pipeline('bbbbbbabba') == 'bbbbbbabba'
>>> apply_pipeline('bbbbba') == 'bbbbba'
"""
raise NotImplementedError()
|
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') == 'baabba'
assert candidate('bba') == 'bba'
assert candidate('bbbbbbabba') == 'bbbbbbabba'
assert candidate('bbbbba') == 'bbbbba'
# hidden tests
assert candidate('abbaaaba') == 'abbaaaba'
assert candidate('bbabab') == 'bbabab'
assert candidate('bbabbabb') == 'bbabbabb'
assert candidate('bbbaaa') == 'bbbaaa'
assert candidate('ba') == 'ba'
assert candidate('bbaaabaab') == 'bbaaabaab'
assert candidate('abbbbaba') == 'abbbbaba'
assert candidate('aab') == 'aab'
assert candidate('abbbbbbb') == 'abbbbbbb'
assert candidate('b') == 'b'
assert candidate('ba') == 'ba'
assert candidate('abbbbbabbb') == 'abbbbbabbb'
assert candidate('abb') == 'abb'
assert candidate('baaababbbb') == 'baaababbbb'
assert candidate('bbbbbbaaaa') == 'bbbbbbaaaa'
assert candidate('baaa') == 'baaa'
assert candidate('aaabaab') == 'aaabaab'
assert candidate('aabaabbaa') == 'aabaabbaa'
assert candidate('baaaa') == 'baaaa'
assert candidate('b') == 'b'
assert candidate('bbbbaa') == 'bbbbaa'
assert candidate('bbbbbaabbb') == 'bbbbbaabbb'
assert candidate('babaaab') == 'babaaab'
assert candidate('babbb') == 'babbb'
assert candidate('b') == 'b'
assert candidate('aabab') == 'aabab'
assert candidate('bbaabbaba') == 'bbaabbaba'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('aba') == 'aba'
assert candidate('bbbabaaa') == 'bbbabaaa'
assert candidate('aaabbabaa') == 'aaabbabaa'
assert candidate('aa') == 'aa'
| 40
|
[
{
"input": "baaabaaab",
"output": "baaabaaab"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "abbbbb",
"output": "abbbbb"
},
{
"input": "aabaaaabbb",
"output": "aabaaaabbb"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "bbbbbbabba",
"output": "bbbbbbabba"
},
{
"input": "bbbbba",
"output": "bbbbba"
}
] |
[
{
"input": "abbaaaba",
"output": "abbaaaba"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "bbabbabb",
"output": "bbabbabb"
},
{
"input": "bbbaaa",
"output": "bbbaaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbaaabaab",
"output": "bbaaabaab"
},
{
"input": "abbbbaba",
"output": "abbbbaba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "abbbbbbb",
"output": "abbbbbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbbbabbb",
"output": "abbbbbabbb"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "baaababbbb",
"output": "baaababbbb"
},
{
"input": "bbbbbbaaaa",
"output": "bbbbbbaaaa"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "aaabaab",
"output": "aaabaab"
},
{
"input": "aabaabbaa",
"output": "aabaabbaa"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "bbbbbaabbb",
"output": "bbbbbaabbb"
},
{
"input": "babaaab",
"output": "babaaab"
},
{
"input": "babbb",
"output": "babbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "bbaabbaba",
"output": "bbaabbaba"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbabaaa",
"output": "bbbabaaa"
},
{
"input": "aaabbabaa",
"output": "aaabbabaa"
},
{
"input": "aa",
"output": "aa"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('ababbb') == 'ABABBB'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('baaab') == 'BAAAB'
>>> apply_pipeline('aabbbbbbaa') == 'AABBBBBBAA'
>>> apply_pipeline('aabab') == 'AABAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('ba') == 'BA'
"""
raise NotImplementedError()
|
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') == 'AABAB'
assert candidate('b') == 'B'
assert candidate('ab') == 'AB'
assert candidate('ba') == 'BA'
# hidden tests
assert candidate('abababa') == 'ABABABA'
assert candidate('abb') == 'ABB'
assert candidate('aabbbaabab') == 'AABBBAABAB'
assert candidate('abbabbaaba') == 'ABBABBAABA'
assert candidate('baaaabbb') == 'BAAABBBB'
assert candidate('aabbbbabba') == 'AABBBBABBA'
assert candidate('abbab') == 'ABBAB'
assert candidate('a') == 'A'
assert candidate('baaa') == 'BAAA'
assert candidate('a') == 'A'
assert candidate('abababbbab') == 'ABABABBBAB'
assert candidate('aabb') == 'AABB'
assert candidate('aababaabab') == 'AABABAABAB'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('bbaabba') == 'BBAABBA'
assert candidate('abbaaab') == 'ABBAAAB'
assert candidate('aaabbbbaa') == 'AAABBBBAA'
assert candidate('bbbaba') == 'BBBABA'
assert candidate('babaa') == 'BABAA'
assert candidate('baabab') == 'BAABAB'
assert candidate('abbb') == 'ABBB'
assert candidate('aaaaabab') == 'AAAABBAB'
assert candidate('aba') == 'ABA'
assert candidate('aabaabbbb') == 'AABAABBBB'
assert candidate('baaaaaab') == 'BAAAAABB'
assert candidate('aaaabababb') == 'AAABBABABB'
assert candidate('bbb') == 'BBB'
assert candidate('aaa') == 'AAA'
assert candidate('b') == 'B'
assert candidate('b') == 'B'
assert candidate('aaaaabb') == 'AAAABBB'
| 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": "ab",
"output": "AB"
},
{
"input": "ba",
"output": "BA"
}
] |
[
{
"input": "abababa",
"output": "ABABABA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "aabbbaabab",
"output": "AABBBAABAB"
},
{
"input": "abbabbaaba",
"output": "ABBABBAABA"
},
{
"input": "baaaabbb",
"output": "BAAABBBB"
},
{
"input": "aabbbbabba",
"output": "AABBBBABBA"
},
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "abababbbab",
"output": "ABABABBBAB"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "aababaabab",
"output": "AABABAABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbaabba",
"output": "BBAABBA"
},
{
"input": "abbaaab",
"output": "ABBAAAB"
},
{
"input": "aaabbbbaa",
"output": "AAABBBBAA"
},
{
"input": "bbbaba",
"output": "BBBABA"
},
{
"input": "babaa",
"output": "BABAA"
},
{
"input": "baabab",
"output": "BAABAB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "aaaaabab",
"output": "AAAABBAB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "aabaabbbb",
"output": "AABAABBBB"
},
{
"input": "baaaaaab",
"output": "BAAAAABB"
},
{
"input": "aaaabababb",
"output": "AAABBABABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaaabb",
"output": "AAAABBB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('babba') == 'BBAABABBAABBBAABA'
>>> apply_pipeline('aaaaab') == 'AAbaabbAAB'
>>> apply_pipeline('abbba') == 'ABBAABBBAABBBAABA'
>>> apply_pipeline('aaabaa') == 'baabbAABAA'
>>> apply_pipeline('b') == 'BBAAB'
>>> apply_pipeline('abbaa') == 'ABBAABBBAABAA'
>>> apply_pipeline('aaabbbb') == 'baabbAABBBAABBBAABBBAAB'
>>> apply_pipeline('bb') == 'BBAABBBAAB'
"""
raise NotImplementedError()
|
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'
assert candidate('b') == 'BBAAB'
assert candidate('abbaa') == 'ABBAABBBAABAA'
assert candidate('aaabbbb') == 'baabbAABBBAABBBAABBBAAB'
assert candidate('bb') == 'BBAABBBAAB'
# hidden tests
assert candidate('aa') == 'AA'
assert candidate('b') == 'BBAAB'
assert candidate('aabaabb') == 'AABBAABAABBAABBBAAB'
assert candidate('a') == 'A'
assert candidate('bababaabb') == 'BBAABABBAABABBAABAABBAABBBAAB'
assert candidate('bbabaabaa') == 'BBAABBBAABABBAABAABBAABAA'
assert candidate('aabbbabaaa') == 'AABBAABBBAABBBAABABBAABAAA'
assert candidate('bbaaa') == 'BBAABBBAABAAA'
assert candidate('aabaabba') == 'AABBAABAABBAABBBAABA'
assert candidate('bbbbaabaab') == 'BBAABBBAABBBAABBBAABAABBAABAABBAAB'
assert candidate('bb') == 'BBAABBBAAB'
assert candidate('baaabbba') == 'BBAABbaabbAABBBAABBBAABA'
assert candidate('bbbaab') == 'BBAABBBAABBBAABAABBAAB'
assert candidate('bb') == 'BBAABBBAAB'
assert candidate('abbaabab') == 'ABBAABBBAABAABBAABABBAAB'
assert candidate('abbbbaaab') == 'ABBAABBBAABBBAABBBAABbaabbAAB'
assert candidate('ababbba') == 'ABBAABABBAABBBAABBBAABA'
assert candidate('aba') == 'ABBAABA'
assert candidate('bbababbaab') == 'BBAABBBAABABBAABABBAABBBAABAABBAAB'
assert candidate('baaaaa') == 'BBAABAAAAA'
assert candidate('abb') == 'ABBAABBBAAB'
assert candidate('baabbbb') == 'BBAABAABBAABBBAABBBAABBBAAB'
assert candidate('aababa') == 'AABBAABABBAABA'
assert candidate('aababa') == 'AABBAABABBAABA'
assert candidate('bbbb') == 'BBAABBBAABBBAABBBAAB'
assert candidate('bbaabaa') == 'BBAABBBAABAABBAABAA'
assert candidate('bbbabaaaa') == 'BBAABBBAABBBAABABBAABAAAA'
assert candidate('a') == 'A'
assert candidate('baaabbba') == 'BBAABbaabbAABBBAABBBAABA'
assert candidate('bbbbaaba') == 'BBAABBBAABBBAABBBAABAABBAABA'
assert candidate('babbbaabba') == 'BBAABABBAABBBAABBBAABAABBAABBBAABA'
assert candidate('baabbaaaba') == 'BBAABAABBAABBBAABbaabbAABA'
| 40
|
[
{
"input": "babba",
"output": "BBAABABBAABBBAABA"
},
{
"input": "aaaaab",
"output": "AAbaabbAAB"
},
{
"input": "abbba",
"output": "ABBAABBBAABBBAABA"
},
{
"input": "aaabaa",
"output": "baabbAABAA"
},
{
"input": "b",
"output": "BBAAB"
},
{
"input": "abbaa",
"output": "ABBAABBBAABAA"
},
{
"input": "aaabbbb",
"output": "baabbAABBBAABBBAABBBAAB"
},
{
"input": "bb",
"output": "BBAABBBAAB"
}
] |
[
{
"input": "aa",
"output": "AA"
},
{
"input": "b",
"output": "BBAAB"
},
{
"input": "aabaabb",
"output": "AABBAABAABBAABBBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bababaabb",
"output": "BBAABABBAABABBAABAABBAABBBAAB"
},
{
"input": "bbabaabaa",
"output": "BBAABBBAABABBAABAABBAABAA"
},
{
"input": "aabbbabaaa",
"output": "AABBAABBBAABBBAABABBAABAAA"
},
{
"input": "bbaaa",
"output": "BBAABBBAABAAA"
},
{
"input": "aabaabba",
"output": "AABBAABAABBAABBBAABA"
},
{
"input": "bbbbaabaab",
"output": "BBAABBBAABBBAABBBAABAABBAABAABBAAB"
},
{
"input": "bb",
"output": "BBAABBBAAB"
},
{
"input": "baaabbba",
"output": "BBAABbaabbAABBBAABBBAABA"
},
{
"input": "bbbaab",
"output": "BBAABBBAABBBAABAABBAAB"
},
{
"input": "bb",
"output": "BBAABBBAAB"
},
{
"input": "abbaabab",
"output": "ABBAABBBAABAABBAABABBAAB"
},
{
"input": "abbbbaaab",
"output": "ABBAABBBAABBBAABBBAABbaabbAAB"
},
{
"input": "ababbba",
"output": "ABBAABABBAABBBAABBBAABA"
},
{
"input": "aba",
"output": "ABBAABA"
},
{
"input": "bbababbaab",
"output": "BBAABBBAABABBAABABBAABBBAABAABBAAB"
},
{
"input": "baaaaa",
"output": "BBAABAAAAA"
},
{
"input": "abb",
"output": "ABBAABBBAAB"
},
{
"input": "baabbbb",
"output": "BBAABAABBAABBBAABBBAABBBAAB"
},
{
"input": "aababa",
"output": "AABBAABABBAABA"
},
{
"input": "aababa",
"output": "AABBAABABBAABA"
},
{
"input": "bbbb",
"output": "BBAABBBAABBBAABBBAAB"
},
{
"input": "bbaabaa",
"output": "BBAABBBAABAABBAABAA"
},
{
"input": "bbbabaaaa",
"output": "BBAABBBAABBBAABABBAABAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaabbba",
"output": "BBAABbaabbAABBBAABBBAABA"
},
{
"input": "bbbbaaba",
"output": "BBAABBBAABBBAABBBAABAABBAABA"
},
{
"input": "babbbaabba",
"output": "BBAABABBAABBBAABBBAABAABBAABBBAABA"
},
{
"input": "baabbaaaba",
"output": "BBAABAABBAABBBAABbaabbAABA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('aababaaa') == 'abaababaaa'
>>> apply_pipeline('aaabb') == 'aaabb'
>>> apply_pipeline('bbabaaba') == 'bbbaababaaba'
>>> apply_pipeline('ab') == 'ab'
>>> apply_pipeline('babba') == 'babba'
>>> apply_pipeline('aa') == 'aa'
>>> apply_pipeline('bb') == 'bb'
"""
raise NotImplementedError()
|
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') == 'ab'
assert candidate('babba') == 'babba'
assert candidate('aa') == 'aa'
assert candidate('bb') == 'bb'
# hidden tests
assert candidate('abaaa') == 'baabaaa'
assert candidate('ba') == 'ba'
assert candidate('ab') == 'ab'
assert candidate('bbaaba') == 'bbabaaba'
assert candidate('a') == 'a'
assert candidate('aababa') == 'abaababa'
assert candidate('abaaaa') == 'baabaaaa'
assert candidate('baabaaaaab') == 'babaabaaaaab'
assert candidate('baaabbb') == 'baaabbb'
assert candidate('aaab') == 'aaab'
assert candidate('abbbaaaaab') == 'abbbaaaaab'
assert candidate('ababaaaab') == 'baababaaaab'
assert candidate('aaaabbab') == 'aaaabbab'
assert candidate('bbaaa') == 'bbaaa'
assert candidate('aaabaaabb') == 'aabaabaaabb'
assert candidate('abaabaa') == 'baababaabaa'
assert candidate('baba') == 'bbaaba'
assert candidate('bb') == 'bb'
assert candidate('b') == 'b'
assert candidate('aba') == 'baaba'
assert candidate('bababba') == 'bbaababba'
assert candidate('aaabaa') == 'aabaabaa'
assert candidate('bbababaa') == 'bbbaababaa'
assert candidate('aabbabbbab') == 'aabbabbbab'
assert candidate('abba') == 'abba'
assert candidate('aabaababbb') == 'abaababaababbb'
assert candidate('bb') == 'bb'
assert candidate('aaba') == 'abaaba'
assert candidate('bba') == 'bba'
assert candidate('ab') == 'ab'
assert candidate('ababb') == 'baababb'
assert candidate('bab') == 'bab'
| 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": "aa",
"output": "aa"
},
{
"input": "bb",
"output": "bb"
}
] |
[
{
"input": "abaaa",
"output": "baabaaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaaba",
"output": "bbabaaba"
},
{
"input": "a",
"output": "a"
},
{
"input": "aababa",
"output": "abaababa"
},
{
"input": "abaaaa",
"output": "baabaaaa"
},
{
"input": "baabaaaaab",
"output": "babaabaaaaab"
},
{
"input": "baaabbb",
"output": "baaabbb"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "abbbaaaaab",
"output": "abbbaaaaab"
},
{
"input": "ababaaaab",
"output": "baababaaaab"
},
{
"input": "aaaabbab",
"output": "aaaabbab"
},
{
"input": "bbaaa",
"output": "bbaaa"
},
{
"input": "aaabaaabb",
"output": "aabaabaaabb"
},
{
"input": "abaabaa",
"output": "baababaabaa"
},
{
"input": "baba",
"output": "bbaaba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "b",
"output": "b"
},
{
"input": "aba",
"output": "baaba"
},
{
"input": "bababba",
"output": "bbaababba"
},
{
"input": "aaabaa",
"output": "aabaabaa"
},
{
"input": "bbababaa",
"output": "bbbaababaa"
},
{
"input": "aabbabbbab",
"output": "aabbabbbab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "aabaababbb",
"output": "abaababaababbb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaba",
"output": "abaaba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ababb",
"output": "baababb"
},
{
"input": "bab",
"output": "bab"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('aababaaa') == 'AABABAAA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('abbbaaabba') == 'ABBBAAABBA'
>>> apply_pipeline('abbaaaabaa') == 'ABBAAAABAA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aabbb') == 'AABBB'
>>> apply_pipeline('aaa') == 'AAA'
"""
raise NotImplementedError()
|
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') == 'ABBAAAABAA'
assert candidate('a') == 'A'
assert candidate('aabbb') == 'AABBB'
assert candidate('aaa') == 'AAA'
# hidden tests
assert candidate('babab') == 'BABAB'
assert candidate('aab') == 'AAB'
assert candidate('abaabbbb') == 'ABAABBBB'
assert candidate('b') == 'B'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('bbbbbabaa') == 'BBBBBABAA'
assert candidate('bbb') == 'BBB'
assert candidate('baaaaaa') == 'BAAAAAA'
assert candidate('abbaaaabb') == 'ABBAAAABB'
assert candidate('babba') == 'BABBA'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('baaa') == 'BAAA'
assert candidate('ba') == 'BA'
assert candidate('ab') == 'AB'
assert candidate('aaaaaba') == 'AAAAABA'
assert candidate('aabaa') == 'AABAA'
assert candidate('aa') == 'AA'
assert candidate('baa') == 'BAA'
assert candidate('bbb') == 'BBB'
assert candidate('aaa') == 'AAA'
assert candidate('aaabaaaabb') == 'AAABAAAABB'
assert candidate('abaabbbaab') == 'ABAABBBAAB'
assert candidate('ba') == 'BA'
assert candidate('aabbbaab') == 'AABBBAAB'
assert candidate('abbbbbab') == 'ABBBBBAB'
assert candidate('baabb') == 'BAABB'
assert candidate('aba') == 'ABA'
assert candidate('baaabba') == 'BAAABBA'
assert candidate('aba') == 'ABA'
assert candidate('abaabb') == 'ABAABB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('babaabbb') == 'BABAABBB'
| 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": "aabbb",
"output": "AABBB"
},
{
"input": "aaa",
"output": "AAA"
}
] |
[
{
"input": "babab",
"output": "BABAB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "bbbbbabaa",
"output": "BBBBBABAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "baaaaaa",
"output": "BAAAAAA"
},
{
"input": "abbaaaabb",
"output": "ABBAAAABB"
},
{
"input": "babba",
"output": "BABBA"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaaaaba",
"output": "AAAAABA"
},
{
"input": "aabaa",
"output": "AABAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaabaaaabb",
"output": "AAABAAAABB"
},
{
"input": "abaabbbaab",
"output": "ABAABBBAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "aabbbaab",
"output": "AABBBAAB"
},
{
"input": "abbbbbab",
"output": "ABBBBBAB"
},
{
"input": "baabb",
"output": "BAABB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "baaabba",
"output": "BAAABBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "abaabb",
"output": "ABAABB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "babaabbb",
"output": "BABAABBB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('baaba') == 'baaba'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('aaaa') == 'aaaa'
>>> apply_pipeline('babbbba') == 'babbbba'
>>> apply_pipeline('baaaa') == 'baaaa'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('ba') == 'ba'
>>> apply_pipeline('bb') == 'bb'
"""
raise NotImplementedError()
|
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'
assert candidate('b') == 'b'
assert candidate('ba') == 'ba'
assert candidate('bb') == 'bb'
# hidden tests
assert candidate('aa') == 'aa'
assert candidate('bbbab') == 'bbbab'
assert candidate('babbbabab') == 'babbbabab'
assert candidate('bbaaaabb') == 'bbaaaabb'
assert candidate('baabb') == 'baabb'
assert candidate('b') == 'b'
assert candidate('baaba') == 'baaba'
assert candidate('bbb') == 'bbb'
assert candidate('b') == 'b'
assert candidate('bb') == 'bb'
assert candidate('bbaabab') == 'bbaabab'
assert candidate('bbaaaba') == 'bbaaaba'
assert candidate('b') == 'b'
assert candidate('bbaa') == 'bbaa'
assert candidate('aab') == 'aab'
assert candidate('bbabab') == 'bbabab'
assert candidate('aabba') == 'aabba'
assert candidate('baaaaab') == 'baaaaab'
assert candidate('baab') == 'baab'
assert candidate('bbaabaaabb') == 'bbaabaaabb'
assert candidate('aaaabbbb') == 'aaaabbbb'
assert candidate('baa') == 'baa'
assert candidate('ababa') == 'ababa'
assert candidate('b') == 'b'
assert candidate('ababb') == 'ababb'
assert candidate('ab') == 'ab'
assert candidate('bba') == 'bba'
assert candidate('bbaaaab') == 'bbaaaab'
assert candidate('bbaa') == 'bbaa'
assert candidate('bbbba') == 'bbbba'
assert candidate('aababbbaa') == 'aababbbaa'
assert candidate('bababa') == 'bababa'
| 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"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bb",
"output": "bb"
}
] |
[
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbab",
"output": "bbbab"
},
{
"input": "babbbabab",
"output": "babbbabab"
},
{
"input": "bbaaaabb",
"output": "bbaaaabb"
},
{
"input": "baabb",
"output": "baabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbaabab",
"output": "bbaabab"
},
{
"input": "bbaaaba",
"output": "bbaaaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "baaaaab",
"output": "baaaaab"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "bbaabaaabb",
"output": "bbaabaaabb"
},
{
"input": "aaaabbbb",
"output": "aaaabbbb"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "ababa",
"output": "ababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "ababb",
"output": "ababb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "bbaaaab",
"output": "bbaaaab"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"input": "aababbbaa",
"output": "aababbbaa"
},
{
"input": "bababa",
"output": "bababa"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('ba') == 'ba'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('aaabaababa') == 'aaabaababa'
>>> apply_pipeline('bbbbbab') == 'bbbbbab'
>>> apply_pipeline('baabbaa') == 'baabbaa'
>>> apply_pipeline('bbbbabba') == 'bbbbabba'
>>> apply_pipeline('abbbbaa') == 'abbbbaa'
>>> apply_pipeline('abb') == 'abb'
"""
raise NotImplementedError()
|
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'
assert candidate('bbbbabba') == 'bbbbabba'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('abb') == 'abb'
# hidden tests
assert candidate('babaabbbba') == 'babaabbbba'
assert candidate('bbbaaabb') == 'bbbaaabb'
assert candidate('abbbabbbb') == 'abbbabbbb'
assert candidate('a') == 'a'
assert candidate('abbba') == 'abbba'
assert candidate('abbabbbbb') == 'abbabbbbb'
assert candidate('aba') == 'aba'
assert candidate('aaaababb') == 'aaaababb'
assert candidate('aaaab') == 'aaaab'
assert candidate('baaaa') == 'baaaa'
assert candidate('baaaab') == 'baaaab'
assert candidate('bbaba') == 'bbaba'
assert candidate('aabbaaaaa') == 'aabbaaaaa'
assert candidate('aab') == 'aab'
assert candidate('bbb') == 'bbb'
assert candidate('ab') == 'ab'
assert candidate('aaabba') == 'aaabba'
assert candidate('bbba') == 'bbba'
assert candidate('bb') == 'bb'
assert candidate('baabaab') == 'baabaab'
assert candidate('bbbabaa') == 'bbbabaa'
assert candidate('aabbbabab') == 'aabbbabab'
assert candidate('a') == 'a'
assert candidate('abbbbbbaba') == 'abbbbbbaba'
assert candidate('babbbab') == 'babbbab'
assert candidate('ab') == 'ab'
assert candidate('abaabba') == 'abaabba'
assert candidate('a') == 'a'
assert candidate('babbaabbb') == 'babbaabbb'
assert candidate('aa') == 'aa'
assert candidate('babbaabb') == 'babbaabb'
assert candidate('abaab') == 'abaab'
| 40
|
[
{
"input": "ba",
"output": "ba"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaabaababa",
"output": "aaabaababa"
},
{
"input": "bbbbbab",
"output": "bbbbbab"
},
{
"input": "baabbaa",
"output": "baabbaa"
},
{
"input": "bbbbabba",
"output": "bbbbabba"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "abb",
"output": "abb"
}
] |
[
{
"input": "babaabbbba",
"output": "babaabbbba"
},
{
"input": "bbbaaabb",
"output": "bbbaaabb"
},
{
"input": "abbbabbbb",
"output": "abbbabbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "abbabbbbb",
"output": "abbabbbbb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "aaaababb",
"output": "aaaababb"
},
{
"input": "aaaab",
"output": "aaaab"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "baaaab",
"output": "baaaab"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "aabbaaaaa",
"output": "aabbaaaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "baabaab",
"output": "baabaab"
},
{
"input": "bbbabaa",
"output": "bbbabaa"
},
{
"input": "aabbbabab",
"output": "aabbbabab"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbbbbaba",
"output": "abbbbbbaba"
},
{
"input": "babbbab",
"output": "babbbab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "abaabba",
"output": "abaabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "babbaabbb",
"output": "babbaabbb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "babbaabb",
"output": "babbaabb"
},
{
"input": "abaab",
"output": "abaab"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbababbba') == 'abbababbba'
>>> apply_pipeline('bab') == 'bab'
>>> apply_pipeline('babbaabaab') == 'babbabbb'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('babaabbaa') == 'bbbbbaa'
>>> apply_pipeline('abaabaaa') == 'bbbaaa'
"""
raise NotImplementedError()
|
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'
assert candidate('b') == 'b'
assert candidate('babaabbaa') == 'bbbbbaa'
assert candidate('abaabaaa') == 'bbbaaa'
# hidden tests
assert candidate('bbaaabbaba') == 'bbabbbaba'
assert candidate('abba') == 'abba'
assert candidate('ba') == 'ba'
assert candidate('bbab') == 'bbab'
assert candidate('aaababba') == 'aaababba'
assert candidate('aaaaaabab') == 'aaaaaabab'
assert candidate('abba') == 'abba'
assert candidate('abbbbab') == 'abbbbab'
assert candidate('baaabbbb') == 'babbbbb'
assert candidate('b') == 'b'
assert candidate('baaa') == 'baaa'
assert candidate('aaaabba') == 'aabbba'
assert candidate('ab') == 'ab'
assert candidate('abbaaba') == 'abbaaba'
assert candidate('abaaba') == 'bbba'
assert candidate('aaaabbaa') == 'aabbbaa'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('baaaabbbab') == 'baabbbbab'
assert candidate('abbb') == 'abbb'
assert candidate('ababbaa') == 'ababbaa'
assert candidate('aa') == 'aa'
assert candidate('aabbbbbaaa') == 'aabbbbbaaa'
assert candidate('a') == 'a'
assert candidate('bbb') == 'bbb'
assert candidate('aabbb') == 'aabbb'
assert candidate('baaaa') == 'baaaa'
assert candidate('abbaaaaba') == 'abbaaaaba'
assert candidate('bbbbbbaa') == 'bbbbbbaa'
assert candidate('abaaaaba') == 'bbaaba'
assert candidate('bbba') == 'bbba'
assert candidate('aabaaba') == 'abbba'
| 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": "babaabbaa",
"output": "bbbbbaa"
},
{
"input": "abaabaaa",
"output": "bbbaaa"
}
] |
[
{
"input": "bbaaabbaba",
"output": "bbabbbaba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaababba",
"output": "aaababba"
},
{
"input": "aaaaaabab",
"output": "aaaaaabab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "abbbbab",
"output": "abbbbab"
},
{
"input": "baaabbbb",
"output": "babbbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "aaaabba",
"output": "aabbba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "abbaaba",
"output": "abbaaba"
},
{
"input": "abaaba",
"output": "bbba"
},
{
"input": "aaaabbaa",
"output": "aabbbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaaabbbab",
"output": "baabbbbab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "ababbaa",
"output": "ababbaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabbbbbaaa",
"output": "aabbbbbaaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "abbaaaaba",
"output": "abbaaaaba"
},
{
"input": "bbbbbbaa",
"output": "bbbbbbaa"
},
{
"input": "abaaaaba",
"output": "bbaaba"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "aabaaba",
"output": "abbba"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('baab') == 'BAAB'
>>> apply_pipeline('aaabbbaab') == 'AAABBBAAB'
>>> apply_pipeline('aabbabaaa') == 'AABBABAAA'
>>> apply_pipeline('ababbbbbab') == 'ABABBBBBAB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aaaabb') == 'AAAABB'
>>> apply_pipeline('baaababaab') == 'BAAABABAAB'
>>> apply_pipeline('babbbb') == 'BABBBB'
"""
raise NotImplementedError()
|
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('a') == 'A'
assert candidate('aaaabb') == 'AAAABB'
assert candidate('baaababaab') == 'BAAABABAAB'
assert candidate('babbbb') == 'BABBBB'
# hidden tests
assert candidate('bab') == 'BAB'
assert candidate('abbbbaabbb') == 'ABBBBAABBB'
assert candidate('babaa') == 'BABAA'
assert candidate('bbbaabaaab') == 'BBBAABAAAB'
assert candidate('baabbabaa') == 'BAABBABAA'
assert candidate('bbbabaaba') == 'BBBABAABA'
assert candidate('bb') == 'BB'
assert candidate('babaab') == 'BABAAB'
assert candidate('ab') == 'AB'
assert candidate('bbaaabab') == 'BBAAABAB'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('abaaa') == 'ABAAA'
assert candidate('abbaa') == 'ABBAA'
assert candidate('a') == 'A'
assert candidate('aabbbaaa') == 'AABBBAAA'
assert candidate('aabaaaa') == 'AABAAAA'
assert candidate('aabaaaa') == 'AABAAAA'
assert candidate('aab') == 'AAB'
assert candidate('abbaabbaa') == 'ABBAABBAA'
assert candidate('abba') == 'ABBA'
assert candidate('b') == 'B'
assert candidate('ababaa') == 'ABABAA'
assert candidate('baaab') == 'BAAAB'
assert candidate('baaba') == 'BAABA'
assert candidate('bbababbaba') == 'BBABABBABA'
assert candidate('bbaaaaabab') == 'BBAAAAABAB'
assert candidate('aaab') == 'AAAB'
assert candidate('baabaaab') == 'BAABAAAB'
assert candidate('abbabb') == 'Aabaa'
assert candidate('a') == 'A'
assert candidate('baaaaa') == 'BAAAAA'
assert candidate('bbabaabaaa') == 'BBABAABAAA'
| 40
|
[
{
"input": "baab",
"output": "BAAB"
},
{
"input": "aaabbbaab",
"output": "AAABBBAAB"
},
{
"input": "aabbabaaa",
"output": "AABBABAAA"
},
{
"input": "ababbbbbab",
"output": "ABABBBBBAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaabb",
"output": "AAAABB"
},
{
"input": "baaababaab",
"output": "BAAABABAAB"
},
{
"input": "babbbb",
"output": "BABBBB"
}
] |
[
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbbbaabbb",
"output": "ABBBBAABBB"
},
{
"input": "babaa",
"output": "BABAA"
},
{
"input": "bbbaabaaab",
"output": "BBBAABAAAB"
},
{
"input": "baabbabaa",
"output": "BAABBABAA"
},
{
"input": "bbbabaaba",
"output": "BBBABAABA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "babaab",
"output": "BABAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbaaabab",
"output": "BBAAABAB"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "abbaa",
"output": "ABBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabbbaaa",
"output": "AABBBAAA"
},
{
"input": "aabaaaa",
"output": "AABAAAA"
},
{
"input": "aabaaaa",
"output": "AABAAAA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "abbaabbaa",
"output": "ABBAABBAA"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ababaa",
"output": "ABABAA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "baaba",
"output": "BAABA"
},
{
"input": "bbababbaba",
"output": "BBABABBABA"
},
{
"input": "bbaaaaabab",
"output": "BBAAAAABAB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "baabaaab",
"output": "BAABAAAB"
},
{
"input": "abbabb",
"output": "Aabaa"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaaaa",
"output": "BAAAAA"
},
{
"input": "bbabaabaaa",
"output": "BBABAABAAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('babbbbaab') == 'babbbbaab'
>>> apply_pipeline('abbbbbbbb') == 'abbbbbbbb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('bbbaabaaa') == 'bbbabbaa'
>>> apply_pipeline('aaa') == 'aaa'
>>> apply_pipeline('aaabaaaa') == 'aabbaaa'
>>> apply_pipeline('bbaaaba') == 'bbaabb'
"""
raise NotImplementedError()
|
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') == 'bbbabbaa'
assert candidate('aaa') == 'aaa'
assert candidate('aaabaaaa') == 'aabbaaa'
assert candidate('bbaaaba') == 'bbaabb'
# hidden tests
assert candidate('aab') == 'aab'
assert candidate('a') == 'a'
assert candidate('bbabba') == 'bbabba'
assert candidate('bab') == 'bab'
assert candidate('abbb') == 'abbb'
assert candidate('baababaaa') == 'babbbaaa'
assert candidate('aababb') == 'abbbb'
assert candidate('abaabbbbaa') == 'bbabbbbaa'
assert candidate('ba') == 'ba'
assert candidate('bbababbab') == 'bbbbbbab'
assert candidate('abb') == 'abb'
assert candidate('abbabbbab') == 'abbabbbab'
assert candidate('aaa') == 'aaa'
assert candidate('bbb') == 'bbb'
assert candidate('abb') == 'abb'
assert candidate('bbbbabb') == 'bbbbabb'
assert candidate('baab') == 'baab'
assert candidate('abbaabbbaa') == 'abbaabbbaa'
assert candidate('aaba') == 'abb'
assert candidate('bba') == 'bba'
assert candidate('a') == 'a'
assert candidate('baaabb') == 'baaabb'
assert candidate('baa') == 'baa'
assert candidate('ab') == 'ab'
assert candidate('bababbbb') == 'bbbbbbb'
assert candidate('aaaaab') == 'aaaaab'
assert candidate('aabbaabbb') == 'aabbaabbb'
assert candidate('aabaa') == 'abba'
assert candidate('abbaaaa') == 'abbaaaa'
assert candidate('aab') == 'aab'
assert candidate('aaaaaa') == 'aaaaaa'
assert candidate('baaabbaba') == 'baaabbbb'
| 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": "aaabaaaa",
"output": "aabbaaa"
},
{
"input": "bbaaaba",
"output": "bbaabb"
}
] |
[
{
"input": "aab",
"output": "aab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabba",
"output": "bbabba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "baababaaa",
"output": "babbbaaa"
},
{
"input": "aababb",
"output": "abbbb"
},
{
"input": "abaabbbbaa",
"output": "bbabbbbaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbababbab",
"output": "bbbbbbab"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "abbabbbab",
"output": "abbabbbab"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbbbabb",
"output": "bbbbabb"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "abbaabbbaa",
"output": "abbaabbbaa"
},
{
"input": "aaba",
"output": "abb"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "a",
"output": "a"
},
{
"input": "baaabb",
"output": "baaabb"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bababbbb",
"output": "bbbbbbb"
},
{
"input": "aaaaab",
"output": "aaaaab"
},
{
"input": "aabbaabbb",
"output": "aabbaabbb"
},
{
"input": "aabaa",
"output": "abba"
},
{
"input": "abbaaaa",
"output": "abbaaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "aaaaaa",
"output": "aaaaaa"
},
{
"input": "baaabbaba",
"output": "baaabbbb"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbbaa') == 'BBBAA'
>>> apply_pipeline('bababaab') == 'ABABAAB'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('bbaaba') == 'BBAABA'
>>> apply_pipeline('aaaaaa') == 'AAAAAA'
>>> apply_pipeline('bbaaabbabb') == 'BBAAABABB'
>>> apply_pipeline('ababa') == 'BBABA'
>>> apply_pipeline('aaaaaaabaa') == 'AAAAAAABAA'
"""
raise NotImplementedError()
|
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'
assert candidate('bbaaabbabb') == 'BBAAABABB'
assert candidate('ababa') == 'BBABA'
assert candidate('aaaaaaabaa') == 'AAAAAAABAA'
# hidden tests
assert candidate('ababa') == 'BBABA'
assert candidate('aaaaaabab') == 'AAAAABBAB'
assert candidate('abaa') == 'ABAA'
assert candidate('ab') == 'AB'
assert candidate('baabbba') == 'BAABBBA'
assert candidate('bababbbbb') == 'ABABBBBB'
assert candidate('baaa') == 'BAAA'
assert candidate('a') == 'A'
assert candidate('abbbab') == 'ABBAB'
assert candidate('bbb') == 'BBB'
assert candidate('baaaab') == 'BAAAAB'
assert candidate('bbabab') == 'BABAB'
assert candidate('aa') == 'AA'
assert candidate('aaaabaabbb') == 'AAAABAABBB'
assert candidate('aaaa') == 'AAAA'
assert candidate('bbbbaba') == 'BBBABA'
assert candidate('baababaa') == 'BABBABAA'
assert candidate('bbaa') == 'BBAA'
assert candidate('bbbbaaaa') == 'BBBBAAAA'
assert candidate('aabbbabbaa') == 'AABBABBAA'
assert candidate('aaba') == 'AABA'
assert candidate('bab') == 'AB'
assert candidate('a') == 'A'
assert candidate('aabb') == 'AABB'
assert candidate('ababbb') == 'BBABBB'
assert candidate('a') == 'A'
assert candidate('ababaa') == 'BBABAA'
assert candidate('bababba') == 'ABABBA'
assert candidate('bababbabab') == 'ABABABAB'
assert candidate('baa') == 'BAA'
assert candidate('baba') == 'ABA'
assert candidate('aabaa') == 'AABAA'
| 40
|
[
{
"input": "bbbaa",
"output": "BBBAA"
},
{
"input": "bababaab",
"output": "ABABAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbaaba",
"output": "BBAABA"
},
{
"input": "aaaaaa",
"output": "AAAAAA"
},
{
"input": "bbaaabbabb",
"output": "BBAAABABB"
},
{
"input": "ababa",
"output": "BBABA"
},
{
"input": "aaaaaaabaa",
"output": "AAAAAAABAA"
}
] |
[
{
"input": "ababa",
"output": "BBABA"
},
{
"input": "aaaaaabab",
"output": "AAAAABBAB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "bababbbbb",
"output": "ABABBBBB"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "abbbab",
"output": "ABBAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "baaaab",
"output": "BAAAAB"
},
{
"input": "bbabab",
"output": "BABAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aaaabaabbb",
"output": "AAAABAABBB"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "bbbbaba",
"output": "BBBABA"
},
{
"input": "baababaa",
"output": "BABBABAA"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "bbbbaaaa",
"output": "BBBBAAAA"
},
{
"input": "aabbbabbaa",
"output": "AABBABBAA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "bab",
"output": "AB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "ababbb",
"output": "BBABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababaa",
"output": "BBABAA"
},
{
"input": "bababba",
"output": "ABABBA"
},
{
"input": "bababbabab",
"output": "ABABABAB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "baba",
"output": "ABA"
},
{
"input": "aabaa",
"output": "AABAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbbabb') == 'ABBBABB'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('aaabaa') == 'AAbab'
>>> apply_pipeline('aaabba') == 'AAABBA'
>>> apply_pipeline('aab') == 'AAB'
>>> apply_pipeline('bbbabaaa') == 'BBBbabA'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('aba') == 'ABA'
"""
raise NotImplementedError()
|
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'
assert candidate('bbbabaaa') == 'BBBbabA'
assert candidate('aaa') == 'AAA'
assert candidate('aba') == 'ABA'
# hidden tests
assert candidate('ab') == 'AB'
assert candidate('baabaaaaab') == 'BAbabAAAB'
assert candidate('aaab') == 'AAAB'
assert candidate('ab') == 'AB'
assert candidate('a') == 'A'
assert candidate('ababbb') == 'ABABBB'
assert candidate('abbbaabba') == 'ABBBAABBA'
assert candidate('aabbabaab') == 'AABBbabB'
assert candidate('aa') == 'AA'
assert candidate('aabb') == 'AABB'
assert candidate('bbb') == 'BBB'
assert candidate('babaaaabaa') == 'BbabAbab'
assert candidate('bab') == 'BAB'
assert candidate('bb') == 'BB'
assert candidate('baa') == 'BAA'
assert candidate('bbaaa') == 'BBAAA'
assert candidate('bbbbaaba') == 'BBBBAABA'
assert candidate('bbbabb') == 'BBBABB'
assert candidate('bbabbbaaa') == 'BBABBBAAA'
assert candidate('aaabbabaa') == 'AAABBbab'
assert candidate('babbbba') == 'BABBBBA'
assert candidate('aa') == 'AA'
assert candidate('babbabb') == 'BABBABB'
assert candidate('bababbaaba') == 'BABABBAABA'
assert candidate('baba') == 'BABA'
assert candidate('bbaaaa') == 'BBAAAA'
assert candidate('bbaaaab') == 'BBAAAAB'
assert candidate('abbbaba') == 'ABBBABA'
assert candidate('a') == 'A'
assert candidate('bbaabbb') == 'BBAABBB'
assert candidate('abbbaaaa') == 'ABBBAAAA'
assert candidate('baabab') == 'BAABAB'
| 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": "aaa",
"output": "AAA"
},
{
"input": "aba",
"output": "ABA"
}
] |
[
{
"input": "ab",
"output": "AB"
},
{
"input": "baabaaaaab",
"output": "BAbabAAAB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababbb",
"output": "ABABBB"
},
{
"input": "abbbaabba",
"output": "ABBBAABBA"
},
{
"input": "aabbabaab",
"output": "AABBbabB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "babaaaabaa",
"output": "BbabAbab"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbaaa",
"output": "BBAAA"
},
{
"input": "bbbbaaba",
"output": "BBBBAABA"
},
{
"input": "bbbabb",
"output": "BBBABB"
},
{
"input": "bbabbbaaa",
"output": "BBABBBAAA"
},
{
"input": "aaabbabaa",
"output": "AAABBbab"
},
{
"input": "babbbba",
"output": "BABBBBA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babbabb",
"output": "BABBABB"
},
{
"input": "bababbaaba",
"output": "BABABBAABA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "bbaaaa",
"output": "BBAAAA"
},
{
"input": "bbaaaab",
"output": "BBAAAAB"
},
{
"input": "abbbaba",
"output": "ABBBABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbaabbb",
"output": "BBAABBB"
},
{
"input": "abbbaaaa",
"output": "ABBBAAAA"
},
{
"input": "baabab",
"output": "BAABAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbabaa') == 'ABBAAABBABAB'
>>> apply_pipeline('abaaaabaa') == 'ABBABABABABBABAB'
>>> apply_pipeline('a') == 'AB'
>>> apply_pipeline('baba') == 'BABBAB'
>>> apply_pipeline('baba') == 'BABBAB'
>>> apply_pipeline('aabaaaab') == 'ABABBABABABABB'
>>> apply_pipeline('aaaabaaaba') == 'ABABABABBABABABBAB'
>>> apply_pipeline('abaabbb') == 'ABBABABBBB'
"""
raise NotImplementedError()
|
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') == 'BABBAB'
assert candidate('aabaaaab') == 'ABABBABABABABB'
assert candidate('aaaabaaaba') == 'ABABABABBABABABBAB'
assert candidate('abaabbb') == 'ABBABABBBB'
# hidden tests
assert candidate('abbbbaaabb') == 'ABBBBAAABABABBB'
assert candidate('b') == 'B'
assert candidate('aababba') == 'ABABBABBAAAB'
assert candidate('abaabbabaa') == 'ABBABABBAAABBABAB'
assert candidate('aababb') == 'ABABBABBB'
assert candidate('bbbab') == 'BBAAABB'
assert candidate('abbbbaba') == 'ABBBBAAABBAB'
assert candidate('a') == 'AB'
assert candidate('a') == 'AB'
assert candidate('abb') == 'ABBB'
assert candidate('aaab') == 'ABABABB'
assert candidate('aabaaabab') == 'ABABBABABABBABB'
assert candidate('bbaaba') == 'BBABABBAB'
assert candidate('bab') == 'BABB'
assert candidate('aabbbbba') == 'ABABBBBBAAAB'
assert candidate('bb') == 'BB'
assert candidate('ba') == 'BAB'
assert candidate('aaba') == 'ABABBAB'
assert candidate('aabb') == 'ABABBB'
assert candidate('baba') == 'BABBAB'
assert candidate('bbbaaaabbb') == 'BBAAABABABABBBB'
assert candidate('abaabbabaa') == 'ABBABABBAAABBABAB'
assert candidate('aaaababa') == 'ABABABABBABBAB'
assert candidate('bbbaabba') == 'BBAAABABBAAAB'
assert candidate('bbb') == 'BBB'
assert candidate('b') == 'B'
assert candidate('baabb') == 'BABABBB'
assert candidate('baba') == 'BABBAB'
assert candidate('bbbaaaaaaa') == 'BBAAABABABABABABAB'
assert candidate('b') == 'B'
assert candidate('aaba') == 'ABABBAB'
assert candidate('bbbaabbaaa') == 'BBAAABABBAAABABAB'
| 40
|
[
{
"input": "abbabaa",
"output": "ABBAAABBABAB"
},
{
"input": "abaaaabaa",
"output": "ABBABABABABBABAB"
},
{
"input": "a",
"output": "AB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "aabaaaab",
"output": "ABABBABABABABB"
},
{
"input": "aaaabaaaba",
"output": "ABABABABBABABABBAB"
},
{
"input": "abaabbb",
"output": "ABBABABBBB"
}
] |
[
{
"input": "abbbbaaabb",
"output": "ABBBBAAABABABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aababba",
"output": "ABABBABBAAAB"
},
{
"input": "abaabbabaa",
"output": "ABBABABBAAABBABAB"
},
{
"input": "aababb",
"output": "ABABBABBB"
},
{
"input": "bbbab",
"output": "BBAAABB"
},
{
"input": "abbbbaba",
"output": "ABBBBAAABBAB"
},
{
"input": "a",
"output": "AB"
},
{
"input": "a",
"output": "AB"
},
{
"input": "abb",
"output": "ABBB"
},
{
"input": "aaab",
"output": "ABABABB"
},
{
"input": "aabaaabab",
"output": "ABABBABABABBABB"
},
{
"input": "bbaaba",
"output": "BBABABBAB"
},
{
"input": "bab",
"output": "BABB"
},
{
"input": "aabbbbba",
"output": "ABABBBBBAAAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "ba",
"output": "BAB"
},
{
"input": "aaba",
"output": "ABABBAB"
},
{
"input": "aabb",
"output": "ABABBB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "bbbaaaabbb",
"output": "BBAAABABABABBBB"
},
{
"input": "abaabbabaa",
"output": "ABBABABBAAABBABAB"
},
{
"input": "aaaababa",
"output": "ABABABABBABBAB"
},
{
"input": "bbbaabba",
"output": "BBAAABABBAAAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baabb",
"output": "BABABBB"
},
{
"input": "baba",
"output": "BABBAB"
},
{
"input": "bbbaaaaaaa",
"output": "BBAAABABABABABABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaba",
"output": "ABABBAB"
},
{
"input": "bbbaabbaaa",
"output": "BBAAABABBAAABABAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('ab') == 'baaabB'
>>> apply_pipeline('babba') == 'BbaaabBBbaaab'
>>> apply_pipeline('bbbbba') == 'BBBBBbaaab'
>>> apply_pipeline('bab') == 'BbaaabB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bbaaab') == 'BBbaaabbaaabbaaabB'
>>> apply_pipeline('bbababaaab') == 'BBbaaabBbaaabBbaaabbaaabbaaabB'
>>> apply_pipeline('abbbbbbba') == 'baaabBBBBBBBbaaab'
"""
raise NotImplementedError()
|
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'
assert candidate('bbaaab') == 'BBbaaabbaaabbaaabB'
assert candidate('bbababaaab') == 'BBbaaabBbaaabBbaaabbaaabbaaabB'
assert candidate('abbbbbbba') == 'baaabBBBBBBBbaaab'
# hidden tests
assert candidate('a') == 'baaab'
assert candidate('aaaaababba') == 'baaabbaaabbaaabbaaabbaaabBbaaabBBbaaab'
assert candidate('bb') == 'BB'
assert candidate('aabbabaa') == 'baaabbaaabBBbaaabBbaaabbaaab'
assert candidate('aaa') == 'baaabbaaabbaaab'
assert candidate('abbbbabbb') == 'baaabBBBBbaaabBBB'
assert candidate('babbbaa') == 'BbaaabBBBbaaabbaaab'
assert candidate('babab') == 'BbaaabBbaaabB'
assert candidate('b') == 'B'
assert candidate('b') == 'B'
assert candidate('bbb') == 'BBB'
assert candidate('a') == 'baaab'
assert candidate('abbaaa') == 'baaabBBbaaabbaaabbaaab'
assert candidate('bbabbb') == 'BBbaaabBBB'
assert candidate('bb') == 'BB'
assert candidate('ababbbaa') == 'baaabBbaaabBBBbaaabbaaab'
assert candidate('a') == 'baaab'
assert candidate('aabb') == 'baaabbaaabBB'
assert candidate('aaaabb') == 'baaabbaaabbaaabbaaabBB'
assert candidate('ab') == 'baaabB'
assert candidate('aa') == 'baaabbaaab'
assert candidate('baababba') == 'BbaaabbaaabBbaaabBBbaaab'
assert candidate('aabbbbaaab') == 'baaabbaaabBBBBbaaabbaaabbaaabB'
assert candidate('aaaaaaaab') == 'baaabbaaabbaaabbaaabbaaabbaaabbaaabbaaabB'
assert candidate('ababaab') == 'baaabBbaaabBbaaabbaaabB'
assert candidate('bbaabbbaa') == 'BBbaaabbaaabBBBbaaabbaaab'
assert candidate('baa') == 'Bbaaabbaaab'
assert candidate('aabaabbb') == 'baaabbaaabBbaaabbaaabBBB'
assert candidate('aabaab') == 'baaabbaaabBbaaabbaaabB'
assert candidate('aabbaab') == 'baaabbaaabBBbaaabbaaabB'
assert candidate('babaaab') == 'BbaaabBbaaabbaaabbaaabB'
assert candidate('a') == 'baaab'
| 40
|
[
{
"input": "ab",
"output": "baaabB"
},
{
"input": "babba",
"output": "BbaaabBBbaaab"
},
{
"input": "bbbbba",
"output": "BBBBBbaaab"
},
{
"input": "bab",
"output": "BbaaabB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaaab",
"output": "BBbaaabbaaabbaaabB"
},
{
"input": "bbababaaab",
"output": "BBbaaabBbaaabBbaaabbaaabbaaabB"
},
{
"input": "abbbbbbba",
"output": "baaabBBBBBBBbaaab"
}
] |
[
{
"input": "a",
"output": "baaab"
},
{
"input": "aaaaababba",
"output": "baaabbaaabbaaabbaaabbaaabBbaaabBBbaaab"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabbabaa",
"output": "baaabbaaabBBbaaabBbaaabbaaab"
},
{
"input": "aaa",
"output": "baaabbaaabbaaab"
},
{
"input": "abbbbabbb",
"output": "baaabBBBBbaaabBBB"
},
{
"input": "babbbaa",
"output": "BbaaabBBBbaaabbaaab"
},
{
"input": "babab",
"output": "BbaaabBbaaabB"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "a",
"output": "baaab"
},
{
"input": "abbaaa",
"output": "baaabBBbaaabbaaabbaaab"
},
{
"input": "bbabbb",
"output": "BBbaaabBBB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "ababbbaa",
"output": "baaabBbaaabBBBbaaabbaaab"
},
{
"input": "a",
"output": "baaab"
},
{
"input": "aabb",
"output": "baaabbaaabBB"
},
{
"input": "aaaabb",
"output": "baaabbaaabbaaabbaaabBB"
},
{
"input": "ab",
"output": "baaabB"
},
{
"input": "aa",
"output": "baaabbaaab"
},
{
"input": "baababba",
"output": "BbaaabbaaabBbaaabBBbaaab"
},
{
"input": "aabbbbaaab",
"output": "baaabbaaabBBBBbaaabbaaabbaaabB"
},
{
"input": "aaaaaaaab",
"output": "baaabbaaabbaaabbaaabbaaabbaaabbaaabbaaabB"
},
{
"input": "ababaab",
"output": "baaabBbaaabBbaaabbaaabB"
},
{
"input": "bbaabbbaa",
"output": "BBbaaabbaaabBBBbaaabbaaab"
},
{
"input": "baa",
"output": "Bbaaabbaaab"
},
{
"input": "aabaabbb",
"output": "baaabbaaabBbaaabbaaabBBB"
},
{
"input": "aabaab",
"output": "baaabbaaabBbaaabbaaabB"
},
{
"input": "aabbaab",
"output": "baaabbaaabBBbaaabbaaabB"
},
{
"input": "babaaab",
"output": "BbaaabBbaaabbaaabbaaabB"
},
{
"input": "a",
"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/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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbaabbbba') == 'BBAABBBBA'
>>> apply_pipeline('bababbabb') == 'BABABBABB'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('aabbb') == 'AABBB'
>>> apply_pipeline('baaabab') == 'BBAAABB'
>>> apply_pipeline('babbbbaabb') == 'BABBBBAABB'
>>> apply_pipeline('aabababa') == 'AABABABA'
>>> apply_pipeline('a') == 'A'
"""
raise NotImplementedError()
|
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') == 'BBAAABB'
assert candidate('babbbbaabb') == 'BABBBBAABB'
assert candidate('aabababa') == 'AABABABA'
assert candidate('a') == 'A'
# hidden tests
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('aababaaaab') == 'AABABAAAAB'
assert candidate('babaabaaa') == 'BABAABAAA'
assert candidate('baabbbbaba') == 'BAABBBBABA'
assert candidate('ababba') == 'ABABBA'
assert candidate('bbba') == 'BBBA'
assert candidate('abbabb') == 'ABBABB'
assert candidate('aaba') == 'AABA'
assert candidate('bbbbaabbab') == 'BBBBAABBAB'
assert candidate('abaa') == 'ABAA'
assert candidate('bb') == 'BB'
assert candidate('baaabaaaa') == 'BBAAABAAA'
assert candidate('bbbababab') == 'BBBABABAB'
assert candidate('aaabbb') == 'AAABBB'
assert candidate('bbbaaaaa') == 'BBBAAAAA'
assert candidate('bbbbbabaab') == 'BBBBBABAAB'
assert candidate('babbbbba') == 'BABBBBBA'
assert candidate('aab') == 'AAB'
assert candidate('bbabbaabb') == 'BBABBAABB'
assert candidate('baabbaab') == 'BAABBAAB'
assert candidate('aaa') == 'AAA'
assert candidate('a') == 'A'
assert candidate('aabababbb') == 'AABABABBB'
assert candidate('abbaabbbb') == 'ABBAABBBB'
assert candidate('ab') == 'AB'
assert candidate('ba') == 'BA'
assert candidate('abab') == 'ABAB'
assert candidate('babab') == 'BABAB'
assert candidate('ba') == 'BA'
assert candidate('aaaabaabb') == 'ABAAABABB'
assert candidate('bab') == 'BAB'
assert candidate('aaaaa') == 'AAAAA'
| 40
|
[
{
"input": "bbaabbbba",
"output": "BBAABBBBA"
},
{
"input": "bababbabb",
"output": "BABABBABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "baaabab",
"output": "BBAAABB"
},
{
"input": "babbbbaabb",
"output": "BABBBBAABB"
},
{
"input": "aabababa",
"output": "AABABABA"
},
{
"input": "a",
"output": "A"
}
] |
[
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "aababaaaab",
"output": "AABABAAAAB"
},
{
"input": "babaabaaa",
"output": "BABAABAAA"
},
{
"input": "baabbbbaba",
"output": "BAABBBBABA"
},
{
"input": "ababba",
"output": "ABABBA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "abbabb",
"output": "ABBABB"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "bbbbaabbab",
"output": "BBBBAABBAB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaabaaaa",
"output": "BBAAABAAA"
},
{
"input": "bbbababab",
"output": "BBBABABAB"
},
{
"input": "aaabbb",
"output": "AAABBB"
},
{
"input": "bbbaaaaa",
"output": "BBBAAAAA"
},
{
"input": "bbbbbabaab",
"output": "BBBBBABAAB"
},
{
"input": "babbbbba",
"output": "BABBBBBA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbabbaabb",
"output": "BBABBAABB"
},
{
"input": "baabbaab",
"output": "BAABBAAB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabababbb",
"output": "AABABABBB"
},
{
"input": "abbaabbbb",
"output": "ABBAABBBB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "babab",
"output": "BABAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "aaaabaabb",
"output": "ABAAABABB"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "aaaaa",
"output": "AAAAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('bbbbaabbbb') == 'bbbbaabbbb'
>>> apply_pipeline('bbaabbaaa') == 'bbaabbaaa'
>>> apply_pipeline('bbbbbb') == 'bbbbbb'
>>> apply_pipeline('aabbab') == 'aabbab'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('babbababbb') == 'babbababbb'
>>> apply_pipeline('bbbaaab') == 'bbbaaab'
"""
raise NotImplementedError()
|
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') == 'aabbab'
assert candidate('b') == 'b'
assert candidate('babbababbb') == 'babbababbb'
assert candidate('bbbaaab') == 'bbbaaab'
# hidden tests
assert candidate('bbbabaaba') == 'bbbabaaba'
assert candidate('baabaa') == 'baabaa'
assert candidate('aaabb') == 'aaabb'
assert candidate('ab') == 'ab'
assert candidate('aababaabbb') == 'aababaabbb'
assert candidate('bbbbaaaaab') == 'bbbbaaaaab'
assert candidate('baa') == 'baa'
assert candidate('bbbbaaaaa') == 'bbbbaaaaa'
assert candidate('aa') == 'aa'
assert candidate('bab') == 'bab'
assert candidate('aa') == 'aa'
assert candidate('bbbbbaabb') == 'bbbbbaabb'
assert candidate('bbbbaaa') == 'bbbbaaa'
assert candidate('abbbb') == 'abbbb'
assert candidate('bb') == 'bb'
assert candidate('abb') == 'abb'
assert candidate('baabba') == 'baabba'
assert candidate('a') == 'a'
assert candidate('baabbabb') == 'baabbabb'
assert candidate('ababbbabb') == 'ababbbabb'
assert candidate('a') == 'a'
assert candidate('bbabaaba') == 'bbabaaba'
assert candidate('aaaabaabab') == 'aaaabaabab'
assert candidate('ba') == 'ba'
assert candidate('abbababbaa') == 'abbababbaa'
assert candidate('abaa') == 'abaa'
assert candidate('ababaabb') == 'ababaabb'
assert candidate('babbabaaa') == 'babbabaaa'
assert candidate('aab') == 'aab'
assert candidate('aaaabbaaba') == 'aaaabbaaba'
assert candidate('bab') == 'bab'
assert candidate('ababb') == 'ababb'
| 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": "babbababbb",
"output": "babbababbb"
},
{
"input": "bbbaaab",
"output": "bbbaaab"
}
] |
[
{
"input": "bbbabaaba",
"output": "bbbabaaba"
},
{
"input": "baabaa",
"output": "baabaa"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aababaabbb",
"output": "aababaabbb"
},
{
"input": "bbbbaaaaab",
"output": "bbbbaaaaab"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bbbbaaaaa",
"output": "bbbbaaaaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbbbaabb",
"output": "bbbbbaabb"
},
{
"input": "bbbbaaa",
"output": "bbbbaaa"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "baabbabb",
"output": "baabbabb"
},
{
"input": "ababbbabb",
"output": "ababbbabb"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabaaba",
"output": "bbabaaba"
},
{
"input": "aaaabaabab",
"output": "aaaabaabab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abbababbaa",
"output": "abbababbaa"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "ababaabb",
"output": "ababaabb"
},
{
"input": "babbabaaa",
"output": "babbabaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "aaaabbaaba",
"output": "aaaabbaaba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "ababb",
"output": "ababb"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('aababab') == 'aababab'
>>> apply_pipeline('ababbbb') == 'ababbbb'
>>> apply_pipeline('aaaab') == 'aaaab'
>>> apply_pipeline('abb') == 'abb'
>>> apply_pipeline('bbaababa') == 'bbaababa'
>>> apply_pipeline('bbab') == 'bbab'
>>> apply_pipeline('bbbaab') == 'bbbaab'
>>> apply_pipeline('abbbabbb') == 'abbbabbb'
"""
raise NotImplementedError()
|
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') == 'bbaababa'
assert candidate('bbab') == 'bbab'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('abbbabbb') == 'abbbabbb'
# hidden tests
assert candidate('aa') == 'aa'
assert candidate('bbb') == 'bbb'
assert candidate('babaab') == 'babaab'
assert candidate('aaabab') == 'aaabab'
assert candidate('bbaab') == 'bbaab'
assert candidate('ba') == 'ba'
assert candidate('bbaa') == 'bbaa'
assert candidate('babbab') == 'babbab'
assert candidate('ababbabaa') == 'ababbabaa'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('abaa') == 'abaa'
assert candidate('bbbbbbabbb') == 'bbbbbbabbb'
assert candidate('babbaa') == 'babbaa'
assert candidate('bbaabba') == 'bbaabba'
assert candidate('bbbb') == 'bbbb'
assert candidate('baaabbba') == 'baaabbba'
assert candidate('babab') == 'babab'
assert candidate('aabaaabaab') == 'aabaaabaab'
assert candidate('bbabbbbab') == 'bbabbbbab'
assert candidate('babbbbbaa') == 'babbbbbaa'
assert candidate('babbaab') == 'babbaab'
assert candidate('bbbaaaaaba') == 'bbabbaaba'
assert candidate('aababa') == 'aababa'
assert candidate('baabbaabab') == 'baabbaabab'
assert candidate('baa') == 'baa'
assert candidate('bbab') == 'bbab'
assert candidate('abab') == 'abab'
assert candidate('aba') == 'aba'
assert candidate('a') == 'a'
assert candidate('bbabbaa') == 'bbabbaa'
assert candidate('babbabbb') == 'babbabbb'
assert candidate('aaabaab') == 'aaabaab'
| 40
|
[
{
"input": "aababab",
"output": "aababab"
},
{
"input": "ababbbb",
"output": "ababbbb"
},
{
"input": "aaaab",
"output": "aaaab"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbaababa",
"output": "bbaababa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "abbbabbb",
"output": "abbbabbb"
}
] |
[
{
"input": "aa",
"output": "aa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "babaab",
"output": "babaab"
},
{
"input": "aaabab",
"output": "aaabab"
},
{
"input": "bbaab",
"output": "bbaab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "babbab",
"output": "babbab"
},
{
"input": "ababbabaa",
"output": "ababbabaa"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "bbbbbbabbb",
"output": "bbbbbbabbb"
},
{
"input": "babbaa",
"output": "babbaa"
},
{
"input": "bbaabba",
"output": "bbaabba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "baaabbba",
"output": "baaabbba"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "aabaaabaab",
"output": "aabaaabaab"
},
{
"input": "bbabbbbab",
"output": "bbabbbbab"
},
{
"input": "babbbbbaa",
"output": "babbbbbaa"
},
{
"input": "babbaab",
"output": "babbaab"
},
{
"input": "bbbaaaaaba",
"output": "bbabbaaba"
},
{
"input": "aababa",
"output": "aababa"
},
{
"input": "baabbaabab",
"output": "baabbaabab"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabbaa",
"output": "bbabbaa"
},
{
"input": "babbabbb",
"output": "babbabbb"
},
{
"input": "aaabaab",
"output": "aaabaab"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('aababa') == 'AAB'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aabbaaaa') == 'AABBAAAA'
>>> apply_pipeline('aaabaabbbb') == 'AAABAABBBB'
>>> apply_pipeline('aabaabaaa') == 'AABAABAAA'
>>> apply_pipeline('abbb') == 'ABBB'
>>> apply_pipeline('bbbabaaba') == 'BBBABAABA'
"""
raise NotImplementedError()
|
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'
assert candidate('aabaabaaa') == 'AABAABAAA'
assert candidate('abbb') == 'ABBB'
assert candidate('bbbabaaba') == 'BBBABAABA'
# hidden tests
assert candidate('baabaa') == 'BAABAA'
assert candidate('abbbaaab') == 'ABBBAAAB'
assert candidate('baabba') == 'BAABBA'
assert candidate('bbabbaaa') == 'BBABBAAA'
assert candidate('bbbaaba') == 'BBBAABA'
assert candidate('babbbbaaaa') == 'BABBBBAAAA'
assert candidate('aabaabbbb') == 'AABAABBBB'
assert candidate('baa') == 'BAA'
assert candidate('bbbabbabaa') == 'BBBABBABAA'
assert candidate('bbab') == 'BBAB'
assert candidate('bbab') == 'BBAB'
assert candidate('aaaabaaaaa') == 'AAAABAAAAA'
assert candidate('babbaaaba') == 'BABBAAABA'
assert candidate('baabaab') == 'BAABAAB'
assert candidate('ba') == 'BA'
assert candidate('ababbbaa') == 'ABABBBAA'
assert candidate('aaaaaaa') == 'AAAAAAA'
assert candidate('bbbaaabb') == 'BBBAAABB'
assert candidate('abaab') == 'ABAAB'
assert candidate('babbbab') == 'BABBBAB'
assert candidate('aabba') == 'AABBA'
assert candidate('baaaa') == 'BAAAA'
assert candidate('aaaabaaabb') == 'AAAABAAABB'
assert candidate('babaaaabaa') == 'BABAAAABAA'
assert candidate('b') == 'B'
assert candidate('bbbb') == 'BBBB'
assert candidate('baababaaba') == 'BAABABA'
assert candidate('baaaabaab') == 'BAAAABAAB'
assert candidate('ab') == 'AB'
assert candidate('bbaabbbb') == 'BBAABBBB'
assert candidate('bba') == 'BBA'
assert candidate('baaaaaaa') == 'BAAAAAAA'
| 40
|
[
{
"input": "aababa",
"output": "AAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabbaaaa",
"output": "AABBAAAA"
},
{
"input": "aaabaabbbb",
"output": "AAABAABBBB"
},
{
"input": "aabaabaaa",
"output": "AABAABAAA"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "bbbabaaba",
"output": "BBBABAABA"
}
] |
[
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "abbbaaab",
"output": "ABBBAAAB"
},
{
"input": "baabba",
"output": "BAABBA"
},
{
"input": "bbabbaaa",
"output": "BBABBAAA"
},
{
"input": "bbbaaba",
"output": "BBBAABA"
},
{
"input": "babbbbaaaa",
"output": "BABBBBAAAA"
},
{
"input": "aabaabbbb",
"output": "AABAABBBB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbbabbabaa",
"output": "BBBABBABAA"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "aaaabaaaaa",
"output": "AAAABAAAAA"
},
{
"input": "babbaaaba",
"output": "BABBAAABA"
},
{
"input": "baabaab",
"output": "BAABAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ababbbaa",
"output": "ABABBBAA"
},
{
"input": "aaaaaaa",
"output": "AAAAAAA"
},
{
"input": "bbbaaabb",
"output": "BBBAAABB"
},
{
"input": "abaab",
"output": "ABAAB"
},
{
"input": "babbbab",
"output": "BABBBAB"
},
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "aaaabaaabb",
"output": "AAAABAAABB"
},
{
"input": "babaaaabaa",
"output": "BABAAAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "baababaaba",
"output": "BAABABA"
},
{
"input": "baaaabaab",
"output": "BAAAABAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbaabbbb",
"output": "BBAABBBB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "baaaaaaa",
"output": "BAAAAAAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('abba') == 'ABBA'
>>> apply_pipeline('babbabbbaa') == 'BABBABBBAA'
>>> apply_pipeline('aababbaaba') == 'AABABBAABA'
>>> apply_pipeline('aaba') == 'AABA'
>>> apply_pipeline('baab') == 'BAAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bb') == 'BB'
"""
raise NotImplementedError()
|
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') == 'AABA'
assert candidate('baab') == 'BAAB'
assert candidate('b') == 'B'
assert candidate('bb') == 'BB'
# hidden tests
assert candidate('abbaab') == 'ABBAAB'
assert candidate('bababb') == 'BABABB'
assert candidate('bbbaab') == 'BBBAAB'
assert candidate('a') == 'A'
assert candidate('bbab') == 'BBAB'
assert candidate('aaaabbabbb') == 'AAAABBABBB'
assert candidate('bab') == 'BAB'
assert candidate('ababaaabab') == 'ABABAAABAB'
assert candidate('aaab') == 'AAAB'
assert candidate('aaba') == 'AABA'
assert candidate('b') == 'B'
assert candidate('bababbbb') == 'BABABBBB'
assert candidate('bbbab') == 'BBBAB'
assert candidate('baabaaabb') == 'BAABAAABB'
assert candidate('ab') == 'AB'
assert candidate('abbabbbba') == 'ABBABBBBA'
assert candidate('aba') == 'ABA'
assert candidate('baabab') == 'BAABAB'
assert candidate('babbababbb') == 'BABBABABBB'
assert candidate('ababaa') == 'ABABAA'
assert candidate('aaabaa') == 'AAABAA'
assert candidate('aaab') == 'AAAB'
assert candidate('ba') == 'BA'
assert candidate('bb') == 'BB'
assert candidate('bbabaab') == 'BBABAAB'
assert candidate('abbbaa') == 'ABBBAA'
assert candidate('baaba') == 'BAABA'
assert candidate('babaaa') == 'BABAAA'
assert candidate('aaaaab') == 'AAAAAB'
assert candidate('babaaab') == 'BABAAAB'
assert candidate('aba') == 'ABA'
assert candidate('bab') == 'BAB'
| 40
|
[
{
"input": "ab",
"output": "AB"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "babbabbbaa",
"output": "BABBABBBAA"
},
{
"input": "aababbaaba",
"output": "AABABBAABA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bb",
"output": "BB"
}
] |
[
{
"input": "abbaab",
"output": "ABBAAB"
},
{
"input": "bababb",
"output": "BABABB"
},
{
"input": "bbbaab",
"output": "BBBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "aaaabbabbb",
"output": "AAAABBABBB"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "ababaaabab",
"output": "ABABAAABAB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababbbb",
"output": "BABABBBB"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "baabaaabb",
"output": "BAABAAABB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abbabbbba",
"output": "ABBABBBBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "baabab",
"output": "BAABAB"
},
{
"input": "babbababbb",
"output": "BABBABABBB"
},
{
"input": "ababaa",
"output": "ABABAA"
},
{
"input": "aaabaa",
"output": "AAABAA"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbabaab",
"output": "BBABAAB"
},
{
"input": "abbbaa",
"output": "ABBBAA"
},
{
"input": "baaba",
"output": "BAABA"
},
{
"input": "babaaa",
"output": "BABAAA"
},
{
"input": "aaaaab",
"output": "AAAAAB"
},
{
"input": "babaaab",
"output": "BABAAAB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "bab",
"output": "BAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbbbbab') == 'ABBBBBAB'
>>> apply_pipeline('abbb') == 'ABBB'
>>> apply_pipeline('aaaaaaba') == 'AAAAAABA'
>>> apply_pipeline('aaabba') == 'AAABBA'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('baabba') == 'BAABBA'
>>> apply_pipeline('baab') == 'BAAB'
>>> apply_pipeline('aaba') == 'AABA'
"""
raise NotImplementedError()
|
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') == 'AA'
assert candidate('baabba') == 'BAABBA'
assert candidate('baab') == 'BAAB'
assert candidate('aaba') == 'AABA'
# hidden tests
assert candidate('abbbbbab') == 'ABBBBBAB'
assert candidate('baababbab') == 'BAABABBAB'
assert candidate('b') == 'B'
assert candidate('aabba') == 'AABBA'
assert candidate('ababbbb') == 'ABABBBB'
assert candidate('bbbbbbba') == 'BBBBBBBA'
assert candidate('aaaaabbbb') == 'AAAAABBBB'
assert candidate('ababa') == 'ABABA'
assert candidate('bbbaaabab') == 'BBBAAABAB'
assert candidate('babaababa') == 'BABAABABA'
assert candidate('aabbbaa') == 'AABBBAA'
assert candidate('baaaaaaa') == 'BAAAAAAA'
assert candidate('abbaaa') == 'ABBAAA'
assert candidate('abbbb') == 'ABBBB'
assert candidate('abbaaa') == 'ABBAAA'
assert candidate('bab') == 'BAB'
assert candidate('bba') == 'BBA'
assert candidate('ab') == 'AB'
assert candidate('aa') == 'AA'
assert candidate('bbbaabb') == 'BBBAABB'
assert candidate('ababbbabaa') == 'ABABBBABAA'
assert candidate('bba') == 'BBA'
assert candidate('ab') == 'AB'
assert candidate('abbab') == 'ABBAB'
assert candidate('bba') == 'BBA'
assert candidate('babbaaabb') == 'BABBAAABB'
assert candidate('bbabbaba') == 'BBABBABA'
assert candidate('aab') == 'AAB'
assert candidate('abbbabb') == 'ABBBABB'
assert candidate('bbbbab') == 'BBBBAB'
assert candidate('abbba') == 'ABBBA'
assert candidate('abaaaaaa') == 'ABAAAAAA'
| 40
|
[
{
"input": "abbbbbab",
"output": "ABBBBBAB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "aaaaaaba",
"output": "AAAAAABA"
},
{
"input": "aaabba",
"output": "AAABBA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baabba",
"output": "BAABBA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "aaba",
"output": "AABA"
}
] |
[
{
"input": "abbbbbab",
"output": "ABBBBBAB"
},
{
"input": "baababbab",
"output": "BAABABBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "ababbbb",
"output": "ABABBBB"
},
{
"input": "bbbbbbba",
"output": "BBBBBBBA"
},
{
"input": "aaaaabbbb",
"output": "AAAAABBBB"
},
{
"input": "ababa",
"output": "ABABA"
},
{
"input": "bbbaaabab",
"output": "BBBAAABAB"
},
{
"input": "babaababa",
"output": "BABAABABA"
},
{
"input": "aabbbaa",
"output": "AABBBAA"
},
{
"input": "baaaaaaa",
"output": "BAAAAAAA"
},
{
"input": "abbaaa",
"output": "ABBAAA"
},
{
"input": "abbbb",
"output": "ABBBB"
},
{
"input": "abbaaa",
"output": "ABBAAA"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbbaabb",
"output": "BBBAABB"
},
{
"input": "ababbbabaa",
"output": "ABABBBABAA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "babbaaabb",
"output": "BABBAAABB"
},
{
"input": "bbabbaba",
"output": "BBABBABA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "abbbabb",
"output": "ABBBABB"
},
{
"input": "bbbbab",
"output": "BBBBAB"
},
{
"input": "abbba",
"output": "ABBBA"
},
{
"input": "abaaaaaa",
"output": "ABAAAAAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbbbbaab') == 'BBBBBABABAAB'
>>> apply_pipeline('aaaaabaabb') == 'AAAABABAABABABAABB'
>>> apply_pipeline('bababaab') == 'BBABAABBABAABABABAAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('ab') == 'BABAAB'
>>> apply_pipeline('abbaabba') == 'BABAABBABABAABBA'
>>> apply_pipeline('aaaabba') == 'AAABABAABBA'
"""
raise NotImplementedError()
|
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'
assert candidate('aaa') == 'AAA'
assert candidate('ab') == 'BABAAB'
assert candidate('abbaabba') == 'BABAABBABABAABBA'
assert candidate('aaaabba') == 'AAABABAABBA'
# hidden tests
assert candidate('aabaa') == 'ABABAABAA'
assert candidate('b') == 'B'
assert candidate('bbabbabbb') == 'BBBABAABBBABAABBB'
assert candidate('bab') == 'BBABAAB'
assert candidate('aaabaa') == 'AABABAABAA'
assert candidate('aaa') == 'AAA'
assert candidate('abbb') == 'BABAABBB'
assert candidate('bb') == 'BB'
assert candidate('bb') == 'BB'
assert candidate('abbaaabaa') == 'BABAABBAABABAABAA'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('baaa') == 'BAAA'
assert candidate('aabb') == 'ABABAABB'
assert candidate('babbaba') == 'BBABAABBBABAABA'
assert candidate('a') == 'A'
assert candidate('aaabababab') == 'AABABAABBABAABBABAABBABAAB'
assert candidate('aabb') == 'ABABAABB'
assert candidate('bbaabbabb') == 'BBABABAABBBABAABB'
assert candidate('abbabba') == 'BABAABBBABAABBA'
assert candidate('aab') == 'ABABAAB'
assert candidate('aa') == 'AA'
assert candidate('babbbaabaa') == 'BBABAABBBABABAABAA'
assert candidate('aaaba') == 'AABABAABA'
assert candidate('bbbbabbb') == 'BBBBBABAABBB'
assert candidate('aaaa') == 'AAAA'
assert candidate('aababbbaaa') == 'ABABAABBABAABBBAAA'
assert candidate('aabbab') == 'ABABAABBBABAAB'
assert candidate('abaabab') == 'BABAABABABAABBABAAB'
assert candidate('aaabaaaa') == 'AABABAABAAAA'
assert candidate('bbba') == 'BBBA'
assert candidate('baaaabbaab') == 'BAAABABAABBABABAAB'
assert candidate('bbaaaab') == 'BBAAABABAAB'
| 40
|
[
{
"input": "bbbbbaab",
"output": "BBBBBABABAAB"
},
{
"input": "aaaaabaabb",
"output": "AAAABABAABABABAABB"
},
{
"input": "bababaab",
"output": "BBABAABBABAABABABAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "ab",
"output": "BABAAB"
},
{
"input": "abbaabba",
"output": "BABAABBABABAABBA"
},
{
"input": "aaaabba",
"output": "AAABABAABBA"
}
] |
[
{
"input": "aabaa",
"output": "ABABAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbabbabbb",
"output": "BBBABAABBBABAABBB"
},
{
"input": "bab",
"output": "BBABAAB"
},
{
"input": "aaabaa",
"output": "AABABAABAA"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "abbb",
"output": "BABAABBB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "abbaaabaa",
"output": "BABAABBAABABAABAA"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "aabb",
"output": "ABABAABB"
},
{
"input": "babbaba",
"output": "BBABAABBBABAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabababab",
"output": "AABABAABBABAABBABAABBABAAB"
},
{
"input": "aabb",
"output": "ABABAABB"
},
{
"input": "bbaabbabb",
"output": "BBABABAABBBABAABB"
},
{
"input": "abbabba",
"output": "BABAABBBABAABBA"
},
{
"input": "aab",
"output": "ABABAAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babbbaabaa",
"output": "BBABAABBBABABAABAA"
},
{
"input": "aaaba",
"output": "AABABAABA"
},
{
"input": "bbbbabbb",
"output": "BBBBBABAABBB"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "aababbbaaa",
"output": "ABABAABBABAABBBAAA"
},
{
"input": "aabbab",
"output": "ABABAABBBABAAB"
},
{
"input": "abaabab",
"output": "BABAABABABAABBABAAB"
},
{
"input": "aaabaaaa",
"output": "AABABAABAAAA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "baaaabbaab",
"output": "BAAABABAABBABABAAB"
},
{
"input": "bbaaaab",
"output": "BBAAABABAAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbab') == 'BBAB'
>>> apply_pipeline('baabbbaa') == 'BAABBBAA'
>>> apply_pipeline('bbababa') == 'BBABABA'
>>> apply_pipeline('aab') == 'AAB'
>>> apply_pipeline('baaaabbb') == 'BAAAABBB'
>>> apply_pipeline('abbbababa') == 'ABBBABABA'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('aaab') == 'AAAB'
"""
raise NotImplementedError()
|
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') == 'BAAAABBB'
assert candidate('abbbababa') == 'ABBBABABA'
assert candidate('ab') == 'AB'
assert candidate('aaab') == 'AAAB'
# hidden tests
assert candidate('bab') == 'BAB'
assert candidate('a') == 'A'
assert candidate('ba') == 'BA'
assert candidate('ababa') == 'ABABA'
assert candidate('bbba') == 'BBBA'
assert candidate('ab') == 'AB'
assert candidate('aaaaabaaa') == 'AAAAABAAA'
assert candidate('babbaba') == 'AABA'
assert candidate('baabbb') == 'BAABBB'
assert candidate('aabbaabbab') == 'AABBAABBAB'
assert candidate('abaaaabbbb') == 'ABAAAABBBB'
assert candidate('bbbbbbba') == 'BBBBBBBA'
assert candidate('babbabbb') == 'AABBB'
assert candidate('abbaa') == 'ABBAA'
assert candidate('babbbb') == 'ABB'
assert candidate('baababbaba') == 'BAAAABA'
assert candidate('ba') == 'BA'
assert candidate('babb') == 'A'
assert candidate('bbbb') == 'BBBB'
assert candidate('babababba') == 'BABAAA'
assert candidate('ab') == 'AB'
assert candidate('bbbababb') == 'BBBAA'
assert candidate('abbbbaaaab') == 'ABBBBAAAAB'
assert candidate('a') == 'A'
assert candidate('ba') == 'BA'
assert candidate('baabaaaaa') == 'BAABAAAAA'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('bbaaabaaba') == 'BBAAABAABA'
assert candidate('aaabbaaab') == 'AAABBAAAB'
assert candidate('abaa') == 'ABAA'
assert candidate('baaa') == 'BAAA'
assert candidate('bbbaa') == 'BBBAA'
| 40
|
[
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "baabbbaa",
"output": "BAABBBAA"
},
{
"input": "bbababa",
"output": "BBABABA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "baaaabbb",
"output": "BAAAABBB"
},
{
"input": "abbbababa",
"output": "ABBBABABA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaab",
"output": "AAAB"
}
] |
[
{
"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": "aaaaabaaa",
"output": "AAAAABAAA"
},
{
"input": "babbaba",
"output": "AABA"
},
{
"input": "baabbb",
"output": "BAABBB"
},
{
"input": "aabbaabbab",
"output": "AABBAABBAB"
},
{
"input": "abaaaabbbb",
"output": "ABAAAABBBB"
},
{
"input": "bbbbbbba",
"output": "BBBBBBBA"
},
{
"input": "babbabbb",
"output": "AABBB"
},
{
"input": "abbaa",
"output": "ABBAA"
},
{
"input": "babbbb",
"output": "ABB"
},
{
"input": "baababbaba",
"output": "BAAAABA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "babb",
"output": "A"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "babababba",
"output": "BABAAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbbababb",
"output": "BBBAA"
},
{
"input": "abbbbaaaab",
"output": "ABBBBAAAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baabaaaaa",
"output": "BAABAAAAA"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "bbaaabaaba",
"output": "BBAAABAABA"
},
{
"input": "aaabbaaab",
"output": "AAABBAAAB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "bbbaa",
"output": "BBBAA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('aababa') == 'ABBABBBABBBABB'
>>> apply_pipeline('aba') == 'ABBBABB'
>>> apply_pipeline('ba') == 'BABB'
>>> apply_pipeline('aaaaaa') == 'ABBABBABBABBABBABB'
>>> apply_pipeline('aabbbbb') == 'ABBABBBBBBB'
>>> apply_pipeline('abbab') == 'ABBBBABBB'
>>> apply_pipeline('bbbbbabaa') == 'BBBBBABBBABBABB'
>>> apply_pipeline('aabba') == 'ABBABBBBABB'
"""
raise NotImplementedError()
|
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('aabbbbb') == 'ABBABBBBBBB'
assert candidate('abbab') == 'ABBBBABBB'
assert candidate('bbbbbabaa') == 'BBBBBABBBABBABB'
assert candidate('aabba') == 'ABBABBBBABB'
# hidden tests
assert candidate('bbbbbba') == 'BBBBBBABB'
assert candidate('abbbaaabb') == 'ABBBBBABBABBABBBB'
assert candidate('baaaabbb') == 'BABBABBABBABBBBB'
assert candidate('aaba') == 'ABBABBBABB'
assert candidate('aba') == 'ABBBABB'
assert candidate('abbaaaa') == 'ABBBBABBABBABBABB'
assert candidate('b') == 'B'
assert candidate('aababaab') == 'ABBABBBABBBABBABBB'
assert candidate('bbbbba') == 'BBBBBABB'
assert candidate('baaabbbbbb') == 'BABBABBABBBBBBBB'
assert candidate('abbaaaa') == 'ABBBBABBABBABBABB'
assert candidate('baab') == 'BABBABBB'
assert candidate('bbbbaaa') == 'BBBBABBABBABB'
assert candidate('bababbbabb') == 'BABBBABBBBBABBBB'
assert candidate('b') == 'B'
assert candidate('ababbb') == 'ABBBABBBBB'
assert candidate('abbabaabab') == 'ABBBBABBBABBABBBABBB'
assert candidate('baaaaaabba') == 'BABBABBABBABBABBABBBBABB'
assert candidate('aab') == 'ABBABBB'
assert candidate('aab') == 'ABBABBB'
assert candidate('baaabb') == 'BABBABBABBBB'
assert candidate('aa') == 'ABBABB'
assert candidate('a') == 'ABB'
assert candidate('abba') == 'ABBBBABB'
assert candidate('babaa') == 'BABBBABBABB'
assert candidate('baababab') == 'BABBABBBABBBABBB'
assert candidate('abbbbb') == 'ABBBBBBB'
assert candidate('babbaab') == 'BABBBBABBABBB'
assert candidate('aaa') == 'ABBABBABB'
assert candidate('a') == 'ABB'
assert candidate('aba') == 'ABBBABB'
assert candidate('abb') == 'ABBBB'
| 40
|
[
{
"input": "aababa",
"output": "ABBABBBABBBABB"
},
{
"input": "aba",
"output": "ABBBABB"
},
{
"input": "ba",
"output": "BABB"
},
{
"input": "aaaaaa",
"output": "ABBABBABBABBABBABB"
},
{
"input": "aabbbbb",
"output": "ABBABBBBBBB"
},
{
"input": "abbab",
"output": "ABBBBABBB"
},
{
"input": "bbbbbabaa",
"output": "BBBBBABBBABBABB"
},
{
"input": "aabba",
"output": "ABBABBBBABB"
}
] |
[
{
"input": "bbbbbba",
"output": "BBBBBBABB"
},
{
"input": "abbbaaabb",
"output": "ABBBBBABBABBABBBB"
},
{
"input": "baaaabbb",
"output": "BABBABBABBABBBBB"
},
{
"input": "aaba",
"output": "ABBABBBABB"
},
{
"input": "aba",
"output": "ABBBABB"
},
{
"input": "abbaaaa",
"output": "ABBBBABBABBABBABB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aababaab",
"output": "ABBABBBABBBABBABBB"
},
{
"input": "bbbbba",
"output": "BBBBBABB"
},
{
"input": "baaabbbbbb",
"output": "BABBABBABBBBBBBB"
},
{
"input": "abbaaaa",
"output": "ABBBBABBABBABBABB"
},
{
"input": "baab",
"output": "BABBABBB"
},
{
"input": "bbbbaaa",
"output": "BBBBABBABBABB"
},
{
"input": "bababbbabb",
"output": "BABBBABBBBBABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "ababbb",
"output": "ABBBABBBBB"
},
{
"input": "abbabaabab",
"output": "ABBBBABBBABBABBBABBB"
},
{
"input": "baaaaaabba",
"output": "BABBABBABBABBABBABBBBABB"
},
{
"input": "aab",
"output": "ABBABBB"
},
{
"input": "aab",
"output": "ABBABBB"
},
{
"input": "baaabb",
"output": "BABBABBABBBB"
},
{
"input": "aa",
"output": "ABBABB"
},
{
"input": "a",
"output": "ABB"
},
{
"input": "abba",
"output": "ABBBBABB"
},
{
"input": "babaa",
"output": "BABBBABBABB"
},
{
"input": "baababab",
"output": "BABBABBBABBBABBB"
},
{
"input": "abbbbb",
"output": "ABBBBBBB"
},
{
"input": "babbaab",
"output": "BABBBBABBABBB"
},
{
"input": "aaa",
"output": "ABBABBABB"
},
{
"input": "a",
"output": "ABB"
},
{
"input": "aba",
"output": "ABBBABB"
},
{
"input": "abb",
"output": "ABBBB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('babbbaba') == 'babbbaba'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('baa') == 'baa'
>>> apply_pipeline('bbb') == 'bbb'
>>> apply_pipeline('ababbbabb') == 'ababbbabb'
>>> apply_pipeline('babbba') == 'babbba'
>>> apply_pipeline('aabbbba') == 'aabbbba'
"""
raise NotImplementedError()
|
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('ababbbabb') == 'ababbbabb'
assert candidate('babbba') == 'babbba'
assert candidate('aabbbba') == 'aabbbba'
# hidden tests
assert candidate('ab') == 'ab'
assert candidate('bbba') == 'bbba'
assert candidate('ab') == 'ab'
assert candidate('bba') == 'bba'
assert candidate('bbaba') == 'bbaba'
assert candidate('bbbaabba') == 'bbbbba'
assert candidate('aa') == 'aa'
assert candidate('aabbba') == 'aabbba'
assert candidate('aaa') == 'aaa'
assert candidate('b') == 'b'
assert candidate('abbab') == 'abbab'
assert candidate('b') == 'b'
assert candidate('abbaaaa') == 'abbaaaa'
assert candidate('aababbbaba') == 'aababbbaba'
assert candidate('aabaaaabaa') == 'aabaaaabaa'
assert candidate('aba') == 'aba'
assert candidate('babaababa') == 'babbaba'
assert candidate('bbabbbbaa') == 'bbabbbbaa'
assert candidate('bbaabab') == 'bbbab'
assert candidate('aaa') == 'aaa'
assert candidate('aaa') == 'aaa'
assert candidate('a') == 'a'
assert candidate('aabaaaa') == 'aabaaaa'
assert candidate('b') == 'b'
assert candidate('ba') == 'ba'
assert candidate('aaabbbbb') == 'aaabbbbb'
assert candidate('aaabbaab') == 'aaabbb'
assert candidate('bbababba') == 'bbababba'
assert candidate('a') == 'a'
assert candidate('babababb') == 'babababb'
assert candidate('bab') == 'bab'
assert candidate('abbbababb') == 'abbbababb'
| 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"
},
{
"input": "babbba",
"output": "babbba"
},
{
"input": "aabbbba",
"output": "aabbbba"
}
] |
[
{
"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": "aa",
"output": "aa"
},
{
"input": "aabbba",
"output": "aabbba"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbab",
"output": "abbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbaaaa",
"output": "abbaaaa"
},
{
"input": "aababbbaba",
"output": "aababbbaba"
},
{
"input": "aabaaaabaa",
"output": "aabaaaabaa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "babaababa",
"output": "babbaba"
},
{
"input": "bbabbbbaa",
"output": "bbabbbbaa"
},
{
"input": "bbaabab",
"output": "bbbab"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabaaaa",
"output": "aabaaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aaabbbbb",
"output": "aaabbbbb"
},
{
"input": "aaabbaab",
"output": "aaabbb"
},
{
"input": "bbababba",
"output": "bbababba"
},
{
"input": "a",
"output": "a"
},
{
"input": "babababb",
"output": "babababb"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abbbababb",
"output": "abbbababb"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abaa') == 'ABAA'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('bababaa') == 'BABABAA'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('bbaa') == 'BBAA'
>>> apply_pipeline('babaaabbbb') == 'BABAAABBBB'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('baaaabaab') == 'BAAAABAAB'
"""
raise NotImplementedError()
|
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 candidate('babaaabbbb') == 'BABAAABBBB'
assert candidate('ba') == 'BA'
assert candidate('baaaabaab') == 'BAAAABAAB'
# hidden tests
assert candidate('baaaaab') == 'BAAAAAB'
assert candidate('ba') == 'BA'
assert candidate('babbaa') == 'BaaaaaA'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('ba') == 'BA'
assert candidate('aaababbaaa') == 'AAABaaaaaAA'
assert candidate('bbabbb') == 'BBABBB'
assert candidate('aab') == 'AAB'
assert candidate('baaab') == 'BAAAB'
assert candidate('abbbabbaa') == 'ABBBaaaaaA'
assert candidate('aababbbabb') == 'AABABBBABB'
assert candidate('abbaababa') == 'aaaaaABABA'
assert candidate('babbab') == 'BaaaaaB'
assert candidate('a') == 'A'
assert candidate('abaabbba') == 'ABAABBBA'
assert candidate('aaaabaabba') == 'AAAABAaaaaa'
assert candidate('abbabbaab') == 'aaaaaBBAAB'
assert candidate('abba') == 'aaaaa'
assert candidate('aab') == 'AAB'
assert candidate('babbbaaaba') == 'BABBBAAABA'
assert candidate('baabba') == 'BAaaaaa'
assert candidate('abbbabbb') == 'ABBBABBB'
assert candidate('a') == 'A'
assert candidate('abbabaa') == 'aaaaaBAA'
assert candidate('bb') == 'BB'
assert candidate('bbbaa') == 'BBBAA'
assert candidate('ba') == 'BA'
assert candidate('abbababab') == 'aaaaaBABAB'
assert candidate('b') == 'B'
assert candidate('aaab') == 'AAAB'
assert candidate('bbab') == 'BBAB'
| 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": "ba",
"output": "BA"
},
{
"input": "baaaabaab",
"output": "BAAAABAAB"
}
] |
[
{
"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": "aaababbaaa",
"output": "AAABaaaaaAA"
},
{
"input": "bbabbb",
"output": "BBABBB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "abbbabbaa",
"output": "ABBBaaaaaA"
},
{
"input": "aababbbabb",
"output": "AABABBBABB"
},
{
"input": "abbaababa",
"output": "aaaaaABABA"
},
{
"input": "babbab",
"output": "BaaaaaB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaabbba",
"output": "ABAABBBA"
},
{
"input": "aaaabaabba",
"output": "AAAABAaaaaa"
},
{
"input": "abbabbaab",
"output": "aaaaaBBAAB"
},
{
"input": "abba",
"output": "aaaaa"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "babbbaaaba",
"output": "BABBBAAABA"
},
{
"input": "baabba",
"output": "BAaaaaa"
},
{
"input": "abbbabbb",
"output": "ABBBABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abbabaa",
"output": "aaaaaBAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbbaa",
"output": "BBBAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "abbababab",
"output": "aaaaaBABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "bbab",
"output": "BBAB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbbbaaba') == 'abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba'
>>> apply_pipeline('baaabaabab') == 'aaabbaabbbaabaaaaaabbaabbbaabaaaaabbaabbbaababbaab'
>>> apply_pipeline('abaaaabb') == 'aaaabbaabbbaabaaaaabbaabbbaab'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('ababa') == 'aaaabbaabbbaabaaaabbaabbbaaba'
>>> apply_pipeline('bbabaabb') == 'bbaabaaabbaabbbaabaaaabbaabbbaabaaabbaabbbaab'
>>> apply_pipeline('bbbbaba') == 'abbaabbbaabbbaabaaabbaabbbaabaaaabbaabbbaaba'
>>> apply_pipeline('bb') == 'abbaabbbaab'
"""
raise NotImplementedError()
|
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') == 'aaaabbaabbbaabaaaaabbaabbbaab'
assert candidate('a') == 'a'
assert candidate('ababa') == 'aaaabbaabbbaabaaaabbaabbbaaba'
assert candidate('bbabaabb') == 'bbaabaaabbaabbbaabaaaabbaabbbaabaaabbaabbbaab'
assert candidate('bbbbaba') == 'abbaabbbaabbbaabaaabbaabbbaabaaaabbaabbbaaba'
assert candidate('bb') == 'abbaabbbaab'
# hidden tests
assert candidate('aabbaaa') == 'aabbaabaaabbaabbbaabaaa'
assert candidate('aaabbbaa') == 'aaaabbaabbbaabaaabbaabbbaabaa'
assert candidate('ba') == 'aaabbaabbbaaba'
assert candidate('aa') == 'aa'
assert candidate('baaabababa') == 'aaabbaabbbaabaaaaaabbaabbbaabaaaabbaabbbaabaaaabbaabbbaaba'
assert candidate('abbaab') == 'abbaabaaabbaabbbaabaabbaab'
assert candidate('aababba') == 'aaaaabbaabbbaababbaabaaabbaabbbaaba'
assert candidate('bbbbaaba') == 'abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba'
assert candidate('baabaab') == 'aaabbaabbbaabaaaaabbaabbbaabaabbaab'
assert candidate('baaababb') == 'aaabbaabbbaabaaaaaabbaabbbaabaabbaabbbaab'
assert candidate('aa') == 'aa'
assert candidate('baaa') == 'aaabbaabbbaabaaa'
assert candidate('baabba') == 'aaabbaabbbaabaabbaabaaabbaabbbaaba'
assert candidate('abaaaaaa') == 'aaaabbaabbbaabaaaaaa'
assert candidate('b') == 'bbaab'
assert candidate('ab') == 'abbaab'
assert candidate('babb') == 'aaabbaabbbaabaabbaabbbaab'
assert candidate('bbaaababb') == 'bbaabaaabbaabbbaabaaaaaabbaabbbaabaabbaabbbaab'
assert candidate('aabaa') == 'aaaaabbaabbbaabaa'
assert candidate('baabbba') == 'aaabbaabbbaabaaabbaabbbaabaaabbaabbbaaba'
assert candidate('baba') == 'aaabbaabbbaabaaaabbaabbbaaba'
assert candidate('baabbaa') == 'aaabbaabbbaabaabbaabaaabbaabbbaabaa'
assert candidate('aa') == 'aa'
assert candidate('ba') == 'aaabbaabbbaaba'
assert candidate('ab') == 'abbaab'
assert candidate('babbbabaa') == 'aaabbaabbbaabaabbaabbbaabaaabbaabbbaabaaaabbaabbbaabaa'
assert candidate('ab') == 'abbaab'
assert candidate('abababb') == 'aaaabbaabbbaabaaaabbaabbbaabaabbaabbbaab'
assert candidate('abbabba') == 'abbaabaaabbaabbbaababbaabaaabbaabbbaaba'
assert candidate('aababaa') == 'aaaaabbaabbbaabaaaabbaabbbaabaa'
assert candidate('aab') == 'aabbaab'
assert candidate('aabbab') == 'aabbaabaaabbaabbbaababbaab'
| 40
|
[
{
"input": "bbbbaaba",
"output": "abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba"
},
{
"input": "baaabaabab",
"output": "aaabbaabbbaabaaaaaabbaabbbaabaaaaabbaabbbaababbaab"
},
{
"input": "abaaaabb",
"output": "aaaabbaabbbaabaaaaabbaabbbaab"
},
{
"input": "a",
"output": "a"
},
{
"input": "ababa",
"output": "aaaabbaabbbaabaaaabbaabbbaaba"
},
{
"input": "bbabaabb",
"output": "bbaabaaabbaabbbaabaaaabbaabbbaabaaabbaabbbaab"
},
{
"input": "bbbbaba",
"output": "abbaabbbaabbbaabaaabbaabbbaabaaaabbaabbbaaba"
},
{
"input": "bb",
"output": "abbaabbbaab"
}
] |
[
{
"input": "aabbaaa",
"output": "aabbaabaaabbaabbbaabaaa"
},
{
"input": "aaabbbaa",
"output": "aaaabbaabbbaabaaabbaabbbaabaa"
},
{
"input": "ba",
"output": "aaabbaabbbaaba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "baaabababa",
"output": "aaabbaabbbaabaaaaaabbaabbbaabaaaabbaabbbaabaaaabbaabbbaaba"
},
{
"input": "abbaab",
"output": "abbaabaaabbaabbbaabaabbaab"
},
{
"input": "aababba",
"output": "aaaaabbaabbbaababbaabaaabbaabbbaaba"
},
{
"input": "bbbbaaba",
"output": "abbaabbbaabbbaabaaabbaabbbaabaaaaabbaabbbaaba"
},
{
"input": "baabaab",
"output": "aaabbaabbbaabaaaaabbaabbbaabaabbaab"
},
{
"input": "baaababb",
"output": "aaabbaabbbaabaaaaaabbaabbbaabaabbaabbbaab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "baaa",
"output": "aaabbaabbbaabaaa"
},
{
"input": "baabba",
"output": "aaabbaabbbaabaabbaabaaabbaabbbaaba"
},
{
"input": "abaaaaaa",
"output": "aaaabbaabbbaabaaaaaa"
},
{
"input": "b",
"output": "bbaab"
},
{
"input": "ab",
"output": "abbaab"
},
{
"input": "babb",
"output": "aaabbaabbbaabaabbaabbbaab"
},
{
"input": "bbaaababb",
"output": "bbaabaaabbaabbbaabaaaaaabbaabbbaabaabbaabbbaab"
},
{
"input": "aabaa",
"output": "aaaaabbaabbbaabaa"
},
{
"input": "baabbba",
"output": "aaabbaabbbaabaaabbaabbbaabaaabbaabbbaaba"
},
{
"input": "baba",
"output": "aaabbaabbbaabaaaabbaabbbaaba"
},
{
"input": "baabbaa",
"output": "aaabbaabbbaabaabbaabaaabbaabbbaabaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "ba",
"output": "aaabbaabbbaaba"
},
{
"input": "ab",
"output": "abbaab"
},
{
"input": "babbbabaa",
"output": "aaabbaabbbaabaabbaabbbaabaaabbaabbbaabaaaabbaabbbaabaa"
},
{
"input": "ab",
"output": "abbaab"
},
{
"input": "abababb",
"output": "aaaabbaabbbaabaaaabbaabbbaabaabbaabbbaab"
},
{
"input": "abbabba",
"output": "abbaabaaabbaabbbaababbaabaaabbaabbbaaba"
},
{
"input": "aababaa",
"output": "aaaaabbaabbbaabaaaabbaabbbaabaa"
},
{
"input": "aab",
"output": "aabbaab"
},
{
"input": "aabbab",
"output": "aabbaabaaabbaabbbaababbaab"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('babbaaaaa') == 'BABBABABBA'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('baabaaba') == 'BAABAABA'
>>> apply_pipeline('baaaabaabb') == 'BABABBBAABB'
>>> apply_pipeline('babbaabbb') == 'BABBAABBB'
>>> apply_pipeline('abaababbab') == 'ABAABABBAB'
>>> apply_pipeline('bbabbaab') == 'BBABBAAB'
>>> apply_pipeline('babbbb') == 'BABBBB'
"""
raise NotImplementedError()
|
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('babbaabbb') == 'BABBAABBB'
assert candidate('abaababbab') == 'ABAABABBAB'
assert candidate('bbabbaab') == 'BBABBAAB'
assert candidate('babbbb') == 'BABBBB'
# hidden tests
assert candidate('aba') == 'ABA'
assert candidate('bb') == 'BB'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('baaaa') == 'BABABB'
assert candidate('abb') == 'ABB'
assert candidate('aa') == 'AA'
assert candidate('bbaaba') == 'BBAABA'
assert candidate('bb') == 'BB'
assert candidate('bbbab') == 'BBBAB'
assert candidate('bbbb') == 'BBBB'
assert candidate('aaababb') == 'BAABB'
assert candidate('aaaa') == 'ABABB'
assert candidate('aaa') == 'AAA'
assert candidate('aaba') == 'AABA'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('abbbaabba') == 'ABBBAABBA'
assert candidate('abbabaabb') == 'ABBABAABB'
assert candidate('bbbbbaba') == 'BBBBBABA'
assert candidate('abaabbaaba') == 'ABAABBAABA'
assert candidate('ababaabaa') == 'ABABAABAA'
assert candidate('aaabaaaa') == 'BAABABB'
assert candidate('aabbaba') == 'AABBABA'
assert candidate('aaabbaabb') == 'AAABBAABB'
assert candidate('babbb') == 'BABBB'
assert candidate('abba') == 'ABBA'
assert candidate('b') == 'B'
assert candidate('bbaab') == 'BBAAB'
assert candidate('baaabaaaba') == 'BBAAAABA'
assert candidate('bbaabbaaaa') == 'BBAABBABABB'
| 40
|
[
{
"input": "babbaaaaa",
"output": "BABBABABBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "baabaaba",
"output": "BAABAABA"
},
{
"input": "baaaabaabb",
"output": "BABABBBAABB"
},
{
"input": "babbaabbb",
"output": "BABBAABBB"
},
{
"input": "abaababbab",
"output": "ABAABABBAB"
},
{
"input": "bbabbaab",
"output": "BBABBAAB"
},
{
"input": "babbbb",
"output": "BABBBB"
}
] |
[
{
"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",
"output": "ABB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbaaba",
"output": "BBAABA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "aaababb",
"output": "BAABB"
},
{
"input": "aaaa",
"output": "ABABB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "abbbaabba",
"output": "ABBBAABBA"
},
{
"input": "abbabaabb",
"output": "ABBABAABB"
},
{
"input": "bbbbbaba",
"output": "BBBBBABA"
},
{
"input": "abaabbaaba",
"output": "ABAABBAABA"
},
{
"input": "ababaabaa",
"output": "ABABAABAA"
},
{
"input": "aaabaaaa",
"output": "BAABABB"
},
{
"input": "aabbaba",
"output": "AABBABA"
},
{
"input": "aaabbaabb",
"output": "AAABBAABB"
},
{
"input": "babbb",
"output": "BABBB"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaab",
"output": "BBAAB"
},
{
"input": "baaabaaaba",
"output": "BBAAAABA"
},
{
"input": "bbaabbaaaa",
"output": "BBAABBABABB"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('abbaaaba') == 'ABBAAABA'
>>> apply_pipeline('ba') == 'BA'
>>> apply_pipeline('baababbaaa') == 'BABABBAAAA'
>>> apply_pipeline('aaaaaabb') == 'AAAAAABB'
>>> apply_pipeline('aaaabbbbb') == 'AAAABBBBB'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('aabaaaba') == 'AABAAABA'
>>> apply_pipeline('ba') == 'BA'
"""
raise NotImplementedError()
|
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('aaaabbbbb') == 'AAAABBBBB'
assert candidate('aaa') == 'AAA'
assert candidate('aabaaaba') == 'AABAAABA'
assert candidate('ba') == 'BA'
# hidden tests
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('aababaaabb') == 'ABABBAAABB'
assert candidate('aa') == 'AA'
assert candidate('abaabbbb') == 'ABAABBBB'
assert candidate('abaaa') == 'ABAAA'
assert candidate('a') == 'A'
assert candidate('babbbbbbba') == 'BABBBBBBBA'
assert candidate('aaba') == 'AABA'
assert candidate('babb') == 'BABB'
assert candidate('bbaabaa') == 'BBAABAA'
assert candidate('baa') == 'BAA'
assert candidate('b') == 'B'
assert candidate('bbabbaa') == 'BBABBAA'
assert candidate('ab') == 'AB'
assert candidate('bbabaabaab') == 'BBABAABAAB'
assert candidate('abaabaabab') == 'ABAABABABB'
assert candidate('bbbaaabbab') == 'BBBAAABBAB'
assert candidate('babbaaa') == 'BABBAAA'
assert candidate('babbbaaa') == 'BABBBAAA'
assert candidate('baabab') == 'BABABB'
assert candidate('a') == 'A'
assert candidate('abaaa') == 'ABAAA'
assert candidate('abaaabaa') == 'ABAAABAA'
assert candidate('b') == 'B'
assert candidate('aa') == 'AA'
assert candidate('baaaba') == 'BAAABA'
assert candidate('baabbbaaa') == 'BAABBBAAA'
assert candidate('babbbaaa') == 'BABBBAAA'
assert candidate('b') == 'B'
assert candidate('abbbbaaab') == 'ABBBBAAAB'
assert candidate('abbaaabbab') == 'ABBAAABBAB'
assert candidate('abbbababa') == 'ABBBBABBA'
| 40
|
[
{
"input": "abbaaaba",
"output": "ABBAAABA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baababbaaa",
"output": "BABABBAAAA"
},
{
"input": "aaaaaabb",
"output": "AAAAAABB"
},
{
"input": "aaaabbbbb",
"output": "AAAABBBBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aabaaaba",
"output": "AABAAABA"
},
{
"input": "ba",
"output": "BA"
}
] |
[
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "aababaaabb",
"output": "ABABBAAABB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbbbbbba",
"output": "BABBBBBBBA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbaabaa",
"output": "BBAABAA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbabbaa",
"output": "BBABBAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbabaabaab",
"output": "BBABAABAAB"
},
{
"input": "abaabaabab",
"output": "ABAABABABB"
},
{
"input": "bbbaaabbab",
"output": "BBBAAABBAB"
},
{
"input": "babbaaa",
"output": "BABBAAA"
},
{
"input": "babbbaaa",
"output": "BABBBAAA"
},
{
"input": "baabab",
"output": "BABABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "abaaabaa",
"output": "ABAAABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baaaba",
"output": "BAAABA"
},
{
"input": "baabbbaaa",
"output": "BAABBBAAA"
},
{
"input": "babbbaaa",
"output": "BABBBAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "abbbbaaab",
"output": "ABBBBAAAB"
},
{
"input": "abbaaabbab",
"output": "ABBAAABBAB"
},
{
"input": "abbbababa",
"output": "ABBBBABBA"
}
] |
{
"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)
which are always applied in the same fixed order.
Your task is to reverse-engineer this pipeline from the examples
and implement it.
Example input/output pairs:
>>> apply_pipeline('bbabb') == 'bbabb'
>>> apply_pipeline('bbaba') == 'bbaba'
>>> apply_pipeline('babbabaabb') == 'babbabaabb'
>>> apply_pipeline('aabbababaa') == 'aabbababaa'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('bba') == 'bba'
>>> apply_pipeline('ab') == 'ab'
"""
raise NotImplementedError()
|
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') == 'b'
assert candidate('b') == 'b'
assert candidate('bba') == 'bba'
assert candidate('ab') == 'ab'
# hidden tests
assert candidate('bbb') == 'bbb'
assert candidate('a') == 'a'
assert candidate('bbaaaba') == 'bbaaaba'
assert candidate('aaa') == 'aaa'
assert candidate('abbbb') == 'abbbb'
assert candidate('babab') == 'babab'
assert candidate('a') == 'a'
assert candidate('ab') == 'ab'
assert candidate('ab') == 'ab'
assert candidate('bbaaaabbb') == 'bbaaaabbb'
assert candidate('aaaabbab') == 'aaaabbab'
assert candidate('abbabaaa') == 'abbabaaa'
assert candidate('aab') == 'aab'
assert candidate('bbab') == 'bbab'
assert candidate('babbab') == 'babbab'
assert candidate('abaaa') == 'abaaa'
assert candidate('bbbbaabbb') == 'bbbbaabbb'
assert candidate('bbbaaa') == 'bbbaaa'
assert candidate('aa') == 'aa'
assert candidate('bbb') == 'bbb'
assert candidate('abbbaababa') == 'abbbaababa'
assert candidate('a') == 'a'
assert candidate('baabbaaab') == 'baabbaaab'
assert candidate('abba') == 'abba'
assert candidate('b') == 'b'
assert candidate('ababababaa') == 'ababababaa'
assert candidate('ab') == 'ab'
assert candidate('bbabbabb') == 'bbabbabb'
assert candidate('bbbba') == 'bbbba'
assert candidate('abababaab') == 'abababaab'
assert candidate('aabb') == 'aabb'
assert candidate('bbaabbbab') == 'bbaabbbab'
| 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": "bba",
"output": "bba"
},
{
"input": "ab",
"output": "ab"
}
] |
[
{
"input": "bbb",
"output": "bbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbaaaba",
"output": "bbaaaba"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "a",
"output": "a"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaaaabbb",
"output": "bbaaaabbb"
},
{
"input": "aaaabbab",
"output": "aaaabbab"
},
{
"input": "abbabaaa",
"output": "abbabaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "babbab",
"output": "babbab"
},
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "bbbbaabbb",
"output": "bbbbaabbb"
},
{
"input": "bbbaaa",
"output": "bbbaaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abbbaababa",
"output": "abbbaababa"
},
{
"input": "a",
"output": "a"
},
{
"input": "baabbaaab",
"output": "baabbaaab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "b",
"output": "b"
},
{
"input": "ababababaa",
"output": "ababababaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbabbabb",
"output": "bbabbabb"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"input": "abababaab",
"output": "abababaab"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "bbaabbbab",
"output": "bbaabbbab"
}
] |
{
"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"
}
|
End of preview. Expand
in Data Studio
PBE World
A synthetic dataset generator for Programming-by-Examples (PBE) tasks focused on string manipulation pipelines. This is a lightly extended version of PBEBench by Naik et al. 2025.
Overview
PBE World generates tasks where models must reverse-engineer a sequence of string method calls from input/output examples. Each task consists of:
- A fixed pipeline of string operations (e.g.,
s.replace(old, new),s.upper(),s.strip(chars)) - Example input/output pairs that demonstrate the pipeline's behavior
- Hidden test cases to validate solutions
Dataset Format
Each line in the output JSONL file contains a single task with the following structure:
{
"task_id": "pbe-world/000000",
"entry_point": "apply_pipeline",
"prompt": "from typing import List\n\ndef apply_pipeline(s: str) -> str:\n \"\"\"Apply a fixed string-manipulation pipeline to the input string `s`.\n \n The pipeline consists of several string method calls such as:\n \n s = s.replace(old, new)\n s = s.upper()\n s = s.lower()\n s = s.strip(chars)\n \n which are always applied in the same fixed order.\n \n Your task is to reverse-engineer this pipeline from the examples\n and implement it.\n \n Example input/output pairs:\n \n >>> apply_pipeline('abbab') == 'aaab'\n >>> apply_pipeline('abbaa') == 'aa'\n >>> apply_pipeline('abaab') == 'baab'\n \"\"\"\n raise NotImplementedError()\n",
"canonical_solution": "def apply_pipeline(s: str) -> str:\n \"\"\"Canonical solution (auto-generated).\"\"\"\n s = s.strip('a')\n s = s.replace('bb', 'aa')\n return s\n",
"canonical_pipeline": [
{
"method": "strip",
"args": [
"a"
]
},
{
"method": "replace",
"args": [
"bb",
"aa"
]
}
],
"test": "from typing import Callable\n\ndef check(candidate: Callable[[str], str]) -> None:\n # examples from the prompt\n assert candidate('abbab') == 'aaab'\n assert candidate('abbaa') == 'aa'\n assert candidate('abaab') == 'baab'\n\n # hidden tests\n assert candidate('ababb') == 'baaa'\n assert candidate('bbbaa') == 'aab'\n assert candidate('bbbab') == 'aabab'\n",
"num_tests": 6,
"examples": [
{
"input": "abbab",
"output": "aaab"
},
{
"input": "abbaa",
"output": "aa"
},
{
"input": "abaab",
"output": "baab"
}
],
"tests": [
{
"input": "ababb",
"output": "baaa"
},
{
"input": "bbbaa",
"output": "aab"
},
{
"input": "bbbab",
"output": "aabab"
}
],
"metadata": {
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 3,
"num_tests": 3,
"generation_params": {
"n_inputs_for_examples": 16,
"l_min": 5,
"l_max": 5,
"pipeline_L_min": 2,
"pipeline_L_max": 2
},
"split": "test",
"version": "1.0.0"
}
}
See schema.json for the complete JSON Schema specification.
Citation
If you use this dataset generator in your research, please cite:
@article{naik2024pbebench,
title={PBEBench: A Multi-Step Programming by Examples Reasoning Benchmark inspired by Historical Linguistics},
author={Naik, Atharva and Prakam and Agrawal, Darsh and Mathur, Yash and Kapadnis, Manav and An, Yuwei and Marr, Clayton and Rose, Carolyn and Mortensen, David},
journal={arXiv preprint arXiv:2505.23126},
year={2025}
}
@software{pbeworld2025,
title={PBE World: A Synthetic Dataset Generator for String Manipulation Tasks},
author={},
year={2025},
url={https://github.com/sbdzdz/pbe-world}
}
- Downloads last month
- 23