Datasets:

Modalities:
Text
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
code
Libraries:
Datasets
pandas
License:
Dataset Viewer
Auto-converted to Parquet Duplicate
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