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"
}
|
pbe-world/000038
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('ababbabbab') == 'ababbabbab'
>>> apply_pipeline('abaabbbba') == 'abaabbbba'
>>> apply_pipeline('bbbab') == 'bbbab'
>>> apply_pipeline('bbbb') == 'bbbb'
>>> apply_pipeline('baababb') == 'baababb'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('aaaabababb') == 'aaaabababb'
>>> apply_pipeline('abbab') == 'abbab'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ababbabbab') == 'ababbabbab'
assert candidate('abaabbbba') == 'abaabbbba'
assert candidate('bbbab') == 'bbbab'
assert candidate('bbbb') == 'bbbb'
assert candidate('baababb') == 'baababb'
assert candidate('a') == 'a'
assert candidate('aaaabababb') == 'aaaabababb'
assert candidate('abbab') == 'abbab'
# hidden tests
assert candidate('a') == 'a'
assert candidate('a') == 'a'
assert candidate('abbbaba') == 'abbbaba'
assert candidate('abba') == 'abba'
assert candidate('abbaaabaa') == 'abbaaabaa'
assert candidate('baaab') == 'baaab'
assert candidate('bb') == 'bb'
assert candidate('b') == 'b'
assert candidate('ab') == 'ab'
assert candidate('aaabaabaa') == 'aaabaabaa'
assert candidate('abaaba') == 'abaaba'
assert candidate('aaaaabab') == 'aaaaabab'
assert candidate('baabbabbba') == 'baabbabbba'
assert candidate('bba') == 'bba'
assert candidate('babbbab') == 'babbbab'
assert candidate('ab') == 'ab'
assert candidate('baaa') == 'baaa'
assert candidate('b') == 'b'
assert candidate('aabbaa') == 'aabbaa'
assert candidate('bb') == 'bb'
assert candidate('bbba') == 'bbba'
assert candidate('ababbb') == 'ababbb'
assert candidate('b') == 'b'
assert candidate('aabbabab') == 'aabbabab'
assert candidate('bbba') == 'bbba'
assert candidate('abbabbbab') == 'abbabbbab'
assert candidate('bbbabb') == 'bbbabb'
assert candidate('aaa') == 'aaa'
assert candidate('abbaabbaaa') == 'abbaabbaaa'
assert candidate('aa') == 'aa'
assert candidate('baaabbbb') == 'baaabbbb'
assert candidate('a') == 'a'
| 40
|
[
{
"input": "ababbabbab",
"output": "ababbabbab"
},
{
"input": "abaabbbba",
"output": "abaabbbba"
},
{
"input": "bbbab",
"output": "bbbab"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "baababb",
"output": "baababb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aaaabababb",
"output": "aaaabababb"
},
{
"input": "abbab",
"output": "abbab"
}
] |
[
{
"input": "a",
"output": "a"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbaba",
"output": "abbbaba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "abbaaabaa",
"output": "abbaaabaa"
},
{
"input": "baaab",
"output": "baaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "b",
"output": "b"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aaabaabaa",
"output": "aaabaabaa"
},
{
"input": "abaaba",
"output": "abaaba"
},
{
"input": "aaaaabab",
"output": "aaaaabab"
},
{
"input": "baabbabbba",
"output": "baabbabbba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "babbbab",
"output": "babbbab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabbaa",
"output": "aabbaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "ababbb",
"output": "ababbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabbabab",
"output": "aabbabab"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "abbabbbab",
"output": "abbabbbab"
},
{
"input": "bbbabb",
"output": "bbbabb"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "abbaabbaaa",
"output": "abbaabbaaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "baaabbbb",
"output": "baaabbbb"
},
{
"input": "a",
"output": "a"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000039
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('baabbbb') == 'BAABBBB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('babaaaa') == 'BABAAAA'
>>> apply_pipeline('b') == 'B'
"""
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('a') == 'A'
assert candidate('baabbbb') == 'BAABBBB'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('a') == 'A'
assert candidate('aa') == 'AA'
assert candidate('babaaaa') == 'BABAAAA'
assert candidate('b') == 'B'
# hidden tests
assert candidate('abaaba') == 'ABAABA'
assert candidate('bbabbbaab') == 'BBABBBAAB'
assert candidate('aababaaba') == 'AABABAABA'
assert candidate('babbbaaaa') == 'BABBBAAAA'
assert candidate('aaaaabaa') == 'AAAAABAA'
assert candidate('aab') == 'AAB'
assert candidate('bb') == 'BB'
assert candidate('baaaabba') == 'BAAAABBA'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('bbaaabaa') == 'BBAAABAA'
assert candidate('abb') == 'ABB'
assert candidate('b') == 'B'
assert candidate('baaab') == 'BAAAB'
assert candidate('abbbbbaaaa') == 'ABBBBBAAAA'
assert candidate('a') == 'A'
assert candidate('ababbbaaaa') == 'ABABBBAAAA'
assert candidate('b') == 'B'
assert candidate('babb') == 'BABB'
assert candidate('aaa') == 'AAA'
assert candidate('bb') == 'BB'
assert candidate('a') == 'A'
assert candidate('bbbbba') == 'BBBBBA'
assert candidate('abaabbb') == 'ABAABBB'
assert candidate('b') == 'B'
assert candidate('bbbabbbaba') == 'BBBABBBABA'
assert candidate('bbab') == 'BBAB'
assert candidate('babaaababa') == 'BABAAABABA'
assert candidate('ba') == 'BA'
| 40
|
[
{
"input": "a",
"output": "A"
},
{
"input": "baabbbb",
"output": "BAABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babaaaa",
"output": "BABAAAA"
},
{
"input": "b",
"output": "B"
}
] |
[
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "bbabbbaab",
"output": "BBABBBAAB"
},
{
"input": "aababaaba",
"output": "AABABAABA"
},
{
"input": "babbbaaaa",
"output": "BABBBAAAA"
},
{
"input": "aaaaabaa",
"output": "AAAAABAA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaaabba",
"output": "BAAAABBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "bbaaabaa",
"output": "BBAAABAA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "abbbbbaaaa",
"output": "ABBBBBAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababbbaaaa",
"output": "ABABBBAAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbbba",
"output": "BBBBBA"
},
{
"input": "abaabbb",
"output": "ABAABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbabbbaba",
"output": "BBBABBBABA"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "babaaababa",
"output": "BABAAABABA"
},
{
"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/000040
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabab') == 'aabab'
>>> apply_pipeline('babbbb') == 'babbbb'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('ab') == 'ab'
>>> apply_pipeline('babb') == 'babb'
>>> apply_pipeline('bbabbb') == 'bbabbb'
>>> apply_pipeline('aaaba') == 'aaaba'
>>> apply_pipeline('baababab') == 'baababab'
"""
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('aabab') == 'aabab'
assert candidate('babbbb') == 'babbbb'
assert candidate('a') == 'a'
assert candidate('ab') == 'ab'
assert candidate('babb') == 'babb'
assert candidate('bbabbb') == 'bbabbb'
assert candidate('aaaba') == 'aaaba'
assert candidate('baababab') == 'baababab'
# hidden tests
assert candidate('aabbbabaa') == 'aabbbabaa'
assert candidate('bbab') == 'bbab'
assert candidate('b') == 'b'
assert candidate('aabaabb') == 'aabaabb'
assert candidate('aa') == 'aa'
assert candidate('aaabaab') == 'aaabaab'
assert candidate('ba') == 'ba'
assert candidate('aabbbbbba') == 'aabbbbbba'
assert candidate('bbaaaa') == 'bbaaaa'
assert candidate('aaa') == 'aaa'
assert candidate('bb') == 'bb'
assert candidate('baa') == 'baa'
assert candidate('bba') == 'bba'
assert candidate('abababa') == 'abababa'
assert candidate('aaaabbbb') == 'aaaabbbb'
assert candidate('aa') == 'aa'
assert candidate('bababaaa') == 'bababaaa'
assert candidate('baba') == 'baba'
assert candidate('bbabbbabb') == 'bbabbbabb'
assert candidate('abbbaaab') == 'abbbaaab'
assert candidate('bb') == 'bb'
assert candidate('ab') == 'ab'
assert candidate('bbaaba') == 'bbaaba'
assert candidate('bbbbaabaaa') == 'bbbbaabaaa'
assert candidate('abaaa') == 'abaaa'
assert candidate('baaaabaaab') == 'baaaabaaab'
assert candidate('bbbbabaaab') == 'bbbbabaaab'
assert candidate('baaaabba') == 'baaaabba'
assert candidate('bbbbaaba') == 'bbbbaaba'
assert candidate('ab') == 'ab'
assert candidate('baabaa') == 'baabaa'
assert candidate('aa') == 'aa'
| 40
|
[
{
"input": "aabab",
"output": "aabab"
},
{
"input": "babbbb",
"output": "babbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "bbabbb",
"output": "bbabbb"
},
{
"input": "aaaba",
"output": "aaaba"
},
{
"input": "baababab",
"output": "baababab"
}
] |
[
{
"input": "aabbbabaa",
"output": "aabbbabaa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabaabb",
"output": "aabaabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aaabaab",
"output": "aaabaab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aabbbbbba",
"output": "aabbbbbba"
},
{
"input": "bbaaaa",
"output": "bbaaaa"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abababa",
"output": "abababa"
},
{
"input": "aaaabbbb",
"output": "aaaabbbb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bababaaa",
"output": "bababaaa"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "bbabbbabb",
"output": "bbabbbabb"
},
{
"input": "abbbaaab",
"output": "abbbaaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaaba",
"output": "bbaaba"
},
{
"input": "bbbbaabaaa",
"output": "bbbbaabaaa"
},
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "baaaabaaab",
"output": "baaaabaaab"
},
{
"input": "bbbbabaaab",
"output": "bbbbabaaab"
},
{
"input": "baaaabba",
"output": "baaaabba"
},
{
"input": "bbbbaaba",
"output": "bbbbaaba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "baabaa",
"output": "baabaa"
},
{
"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/000041
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbbb') == 'bbbb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('ba') == 'ba'
>>> apply_pipeline('baa') == 'baa'
>>> apply_pipeline('babba') == 'babba'
>>> apply_pipeline('babaab') == 'babaab'
>>> apply_pipeline('aaabba') == 'aaabba'
>>> apply_pipeline('aab') == 'aab'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbb') == 'bbbb'
assert candidate('b') == 'b'
assert candidate('ba') == 'ba'
assert candidate('baa') == 'baa'
assert candidate('babba') == 'babba'
assert candidate('babaab') == 'babaab'
assert candidate('aaabba') == 'aaabba'
assert candidate('aab') == 'aab'
# hidden tests
assert candidate('aababbaaa') == 'aababbaaa'
assert candidate('bbabbaab') == 'bbabbaab'
assert candidate('baaa') == 'baaa'
assert candidate('baaabbbba') == 'baaabbbba'
assert candidate('baaaaaaa') == 'baaaaaaa'
assert candidate('aab') == 'aab'
assert candidate('aaaaaaa') == 'aaaaaaa'
assert candidate('bbbb') == 'bbbb'
assert candidate('ab') == 'ab'
assert candidate('babbabbb') == 'babbabbb'
assert candidate('aabb') == 'aabb'
assert candidate('aaaa') == 'aaaa'
assert candidate('bbaaaabaaa') == 'bbaaaabaaa'
assert candidate('bbaaabaaa') == 'bbaaabaaa'
assert candidate('ababb') == 'ababb'
assert candidate('babbb') == 'babbb'
assert candidate('baaba') == 'baaba'
assert candidate('bababab') == 'bababab'
assert candidate('aaababbbb') == 'aaababbbb'
assert candidate('aabaa') == 'aabaa'
assert candidate('aaaaaaaa') == 'aaaaaaaa'
assert candidate('baabbaaba') == 'baabbaaba'
assert candidate('baaababb') == 'baaababb'
assert candidate('bab') == 'bab'
assert candidate('aa') == 'aa'
assert candidate('bbb') == 'bbb'
assert candidate('abaa') == 'abaa'
assert candidate('b') == 'b'
assert candidate('aaaba') == 'aaaba'
assert candidate('bbbaaaa') == 'bbbaaaa'
assert candidate('bbbb') == 'bbbb'
assert candidate('b') == 'b'
| 40
|
[
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "babba",
"output": "babba"
},
{
"input": "babaab",
"output": "babaab"
},
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "aab",
"output": "aab"
}
] |
[
{
"input": "aababbaaa",
"output": "aababbaaa"
},
{
"input": "bbabbaab",
"output": "bbabbaab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "baaabbbba",
"output": "baaabbbba"
},
{
"input": "baaaaaaa",
"output": "baaaaaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "aaaaaaa",
"output": "aaaaaaa"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "babbabbb",
"output": "babbabbb"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "bbaaaabaaa",
"output": "bbaaaabaaa"
},
{
"input": "bbaaabaaa",
"output": "bbaaabaaa"
},
{
"input": "ababb",
"output": "ababb"
},
{
"input": "babbb",
"output": "babbb"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "bababab",
"output": "bababab"
},
{
"input": "aaababbbb",
"output": "aaababbbb"
},
{
"input": "aabaa",
"output": "aabaa"
},
{
"input": "aaaaaaaa",
"output": "aaaaaaaa"
},
{
"input": "baabbaaba",
"output": "baabbaaba"
},
{
"input": "baaababb",
"output": "baaababb"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaaba",
"output": "aaaba"
},
{
"input": "bbbaaaa",
"output": "bbbaaaa"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "b",
"output": "b"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000042
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aab') == 'ABAAbaabaabbAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('a') == 'ABAAA'
>>> apply_pipeline('aaabbba') == 'ABAAbaabaabbbaabaabbABBBABAAA'
>>> apply_pipeline('abbaaaa') == 'ABAAABBABAAbaabaabbbaabaabbbaabaabbA'
>>> apply_pipeline('baa') == 'BABAAbaabaabbA'
>>> apply_pipeline('aaa') == 'ABAAbaabaabbbaabaabbA'
>>> apply_pipeline('b') == 'B'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'abaaa')
s = s.upper()
s = s.upper()
s = s.replace('AABA', 'baaa')
s = s.replace('aA', 'baabb')
return s
|
[
{
"method": "replace",
"args": [
"a",
"abaaa"
]
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AABA",
"baaa"
]
},
{
"method": "replace",
"args": [
"aA",
"baabb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aab') == 'ABAAbaabaabbAB'
assert candidate('b') == 'B'
assert candidate('a') == 'ABAAA'
assert candidate('aaabbba') == 'ABAAbaabaabbbaabaabbABBBABAAA'
assert candidate('abbaaaa') == 'ABAAABBABAAbaabaabbbaabaabbbaabaabbA'
assert candidate('baa') == 'BABAAbaabaabbA'
assert candidate('aaa') == 'ABAAbaabaabbbaabaabbA'
assert candidate('b') == 'B'
# hidden tests
assert candidate('ababba') == 'ABAbaaaBAAABBABAAA'
assert candidate('bbbaabb') == 'BBBABAAbaabaabbABB'
assert candidate('aaabaaabbb') == 'ABAAbaabaabbbaaabaaaBAAbaabaabbbaabaabbABBB'
assert candidate('ba') == 'BABAAA'
assert candidate('babbba') == 'BABAAABBBABAAA'
assert candidate('a') == 'ABAAA'
assert candidate('bbbbaba') == 'BBBBABAbaaaBAAA'
assert candidate('bba') == 'BBABAAA'
assert candidate('abbab') == 'ABAAABBABAAAB'
assert candidate('abbaabb') == 'ABAAABBABAAbaabaabbABB'
assert candidate('abbbabbb') == 'ABAAABBBABAAABBB'
assert candidate('a') == 'ABAAA'
assert candidate('bbbbbbbba') == 'BBBBBBBBABAAA'
assert candidate('ababbabbb') == 'ABAbaaaBAAABBABAAABBB'
assert candidate('babb') == 'BABAAABB'
assert candidate('abbbaababa') == 'ABAAABBBABAAbaaabaaaBAbaaaBAAA'
assert candidate('aa') == 'ABAAbaabaabbA'
assert candidate('ababbba') == 'ABAbaaaBAAABBBABAAA'
assert candidate('a') == 'ABAAA'
assert candidate('bbaaa') == 'BBABAAbaabaabbbaabaabbA'
assert candidate('aabbbabba') == 'ABAAbaabaabbABBBABAAABBABAAA'
assert candidate('bbaaabbaa') == 'BBABAAbaabaabbbaabaabbABBABAAbaabaabbA'
assert candidate('a') == 'ABAAA'
assert candidate('b') == 'B'
assert candidate('babaabb') == 'BABAbaaaBAAbaabaabbABB'
assert candidate('ababb') == 'ABAbaaaBAAABB'
assert candidate('babaaba') == 'BABAbaaaBAAbaaabaaaBAAA'
assert candidate('aaaabba') == 'ABAAbaabaabbbaabaabbbaabaabbABBABAAA'
assert candidate('a') == 'ABAAA'
assert candidate('bbbaa') == 'BBBABAAbaabaabbA'
assert candidate('bbbbbba') == 'BBBBBBABAAA'
assert candidate('abaaa') == 'ABAbaaaBAAbaabaabbbaabaabbA'
| 40
|
[
{
"input": "aab",
"output": "ABAAbaabaabbAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "aaabbba",
"output": "ABAAbaabaabbbaabaabbABBBABAAA"
},
{
"input": "abbaaaa",
"output": "ABAAABBABAAbaabaabbbaabaabbbaabaabbA"
},
{
"input": "baa",
"output": "BABAAbaabaabbA"
},
{
"input": "aaa",
"output": "ABAAbaabaabbbaabaabbA"
},
{
"input": "b",
"output": "B"
}
] |
[
{
"input": "ababba",
"output": "ABAbaaaBAAABBABAAA"
},
{
"input": "bbbaabb",
"output": "BBBABAAbaabaabbABB"
},
{
"input": "aaabaaabbb",
"output": "ABAAbaabaabbbaaabaaaBAAbaabaabbbaabaabbABBB"
},
{
"input": "ba",
"output": "BABAAA"
},
{
"input": "babbba",
"output": "BABAAABBBABAAA"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "bbbbaba",
"output": "BBBBABAbaaaBAAA"
},
{
"input": "bba",
"output": "BBABAAA"
},
{
"input": "abbab",
"output": "ABAAABBABAAAB"
},
{
"input": "abbaabb",
"output": "ABAAABBABAAbaabaabbABB"
},
{
"input": "abbbabbb",
"output": "ABAAABBBABAAABBB"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "bbbbbbbba",
"output": "BBBBBBBBABAAA"
},
{
"input": "ababbabbb",
"output": "ABAbaaaBAAABBABAAABBB"
},
{
"input": "babb",
"output": "BABAAABB"
},
{
"input": "abbbaababa",
"output": "ABAAABBBABAAbaaabaaaBAbaaaBAAA"
},
{
"input": "aa",
"output": "ABAAbaabaabbA"
},
{
"input": "ababbba",
"output": "ABAbaaaBAAABBBABAAA"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "bbaaa",
"output": "BBABAAbaabaabbbaabaabbA"
},
{
"input": "aabbbabba",
"output": "ABAAbaabaabbABBBABAAABBABAAA"
},
{
"input": "bbaaabbaa",
"output": "BBABAAbaabaabbbaabaabbABBABAAbaabaabbA"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "babaabb",
"output": "BABAbaaaBAAbaabaabbABB"
},
{
"input": "ababb",
"output": "ABAbaaaBAAABB"
},
{
"input": "babaaba",
"output": "BABAbaaaBAAbaaabaaaBAAA"
},
{
"input": "aaaabba",
"output": "ABAAbaabaabbbaabaabbbaabaabbABBABAAA"
},
{
"input": "a",
"output": "ABAAA"
},
{
"input": "bbbaa",
"output": "BBBABAAbaabaabbA"
},
{
"input": "bbbbbba",
"output": "BBBBBBABAAA"
},
{
"input": "abaaa",
"output": "ABAbaaaBAAbaabaabbbaabaabbA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000043
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbbbbabb') == 'BBABBBBABBBBABBBBABBAA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('babbbb') == 'BBABBBBABBBBABBA'
>>> apply_pipeline('aaaabaa') == 'BBABBAAAA'
>>> apply_pipeline('bbbabb') == 'BBABBBBABBBBABBA'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('aaaaaa') == 'BBABBA'
>>> apply_pipeline('aaa') == 'AAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('b', 'aaa')
s = s.replace('aaaaa', 'bbabb')
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"b",
"aaa"
]
},
{
"method": "replace",
"args": [
"aaaaa",
"bbabb"
]
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbbbbabb') == 'BBABBBBABBBBABBBBABBAA'
assert candidate('a') == 'A'
assert candidate('babbbb') == 'BBABBBBABBBBABBA'
assert candidate('aaaabaa') == 'BBABBAAAA'
assert candidate('bbbabb') == 'BBABBBBABBBBABBA'
assert candidate('aaa') == 'AAA'
assert candidate('aaaaaa') == 'BBABBA'
assert candidate('aaa') == 'AAA'
# hidden tests
assert candidate('baababab') == 'BBABBBBABBBBABBA'
assert candidate('b') == 'AAA'
assert candidate('bbbababbab') == 'BBABBBBABBBBABBBBABBAAAA'
assert candidate('aaaaaabba') == 'BBABBBBABBAAA'
assert candidate('ab') == 'AAAA'
assert candidate('abbaaaabb') == 'BBABBBBABBBBABBAA'
assert candidate('abbabbaaba') == 'BBABBBBABBBBABBBBABB'
assert candidate('ababaa') == 'BBABBBBABB'
assert candidate('aaaaaaa') == 'BBABBAA'
assert candidate('abbabbaab') == 'BBABBBBABBBBABBAAAA'
assert candidate('a') == 'A'
assert candidate('baaabbaab') == 'BBABBBBABBBBABBAA'
assert candidate('baba') == 'BBABBAAA'
assert candidate('babbab') == 'BBABBBBABBAAAA'
assert candidate('ab') == 'AAAA'
assert candidate('baabaaabb') == 'BBABBBBABBBBABBAA'
assert candidate('abbbaab') == 'BBABBBBABBBBABB'
assert candidate('bababba') == 'BBABBBBABBBBABB'
assert candidate('bb') == 'BBABBA'
assert candidate('baaa') == 'BBABBA'
assert candidate('babaabbb') == 'BBABBBBABBBBABBAAA'
assert candidate('b') == 'AAA'
assert candidate('baab') == 'BBABBAAA'
assert candidate('babaa') == 'BBABBAAAA'
assert candidate('bb') == 'BBABBA'
assert candidate('bbbb') == 'BBABBBBABBAA'
assert candidate('b') == 'AAA'
assert candidate('aa') == 'AA'
assert candidate('aabaababb') == 'BBABBBBABBBBABBAA'
assert candidate('baab') == 'BBABBAAA'
assert candidate('bbaab') == 'BBABBBBABBA'
assert candidate('abab') == 'BBABBAAA'
| 40
|
[
{
"input": "bbbbbabb",
"output": "BBABBBBABBBBABBBBABBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbbb",
"output": "BBABBBBABBBBABBA"
},
{
"input": "aaaabaa",
"output": "BBABBAAAA"
},
{
"input": "bbbabb",
"output": "BBABBBBABBBBABBA"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaaaaa",
"output": "BBABBA"
},
{
"input": "aaa",
"output": "AAA"
}
] |
[
{
"input": "baababab",
"output": "BBABBBBABBBBABBA"
},
{
"input": "b",
"output": "AAA"
},
{
"input": "bbbababbab",
"output": "BBABBBBABBBBABBBBABBAAAA"
},
{
"input": "aaaaaabba",
"output": "BBABBBBABBAAA"
},
{
"input": "ab",
"output": "AAAA"
},
{
"input": "abbaaaabb",
"output": "BBABBBBABBBBABBAA"
},
{
"input": "abbabbaaba",
"output": "BBABBBBABBBBABBBBABB"
},
{
"input": "ababaa",
"output": "BBABBBBABB"
},
{
"input": "aaaaaaa",
"output": "BBABBAA"
},
{
"input": "abbabbaab",
"output": "BBABBBBABBBBABBAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaabbaab",
"output": "BBABBBBABBBBABBAA"
},
{
"input": "baba",
"output": "BBABBAAA"
},
{
"input": "babbab",
"output": "BBABBBBABBAAAA"
},
{
"input": "ab",
"output": "AAAA"
},
{
"input": "baabaaabb",
"output": "BBABBBBABBBBABBAA"
},
{
"input": "abbbaab",
"output": "BBABBBBABBBBABB"
},
{
"input": "bababba",
"output": "BBABBBBABBBBABB"
},
{
"input": "bb",
"output": "BBABBA"
},
{
"input": "baaa",
"output": "BBABBA"
},
{
"input": "babaabbb",
"output": "BBABBBBABBBBABBAAA"
},
{
"input": "b",
"output": "AAA"
},
{
"input": "baab",
"output": "BBABBAAA"
},
{
"input": "babaa",
"output": "BBABBAAAA"
},
{
"input": "bb",
"output": "BBABBA"
},
{
"input": "bbbb",
"output": "BBABBBBABBAA"
},
{
"input": "b",
"output": "AAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabaababb",
"output": "BBABBBBABBBBABBAA"
},
{
"input": "baab",
"output": "BBABBAAA"
},
{
"input": "bbaab",
"output": "BBABBBBABBA"
},
{
"input": "abab",
"output": "BBABBAAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000044
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaabb') == 'BBAABB'
>>> apply_pipeline('bbabaa') == 'BBABAA'
>>> apply_pipeline('abbaaba') == 'ABBAABA'
>>> apply_pipeline('bbaaabaa') == 'BBAAABAA'
>>> apply_pipeline('baaab') == 'BAAAB'
>>> apply_pipeline('abaaaaab') == 'ABAAAAAB'
>>> apply_pipeline('bababbaaa') == 'BABABBAAA'
>>> apply_pipeline('bb') == 'BB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
s = s.lower()
s = s.upper()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaabb') == 'BBAABB'
assert candidate('bbabaa') == 'BBABAA'
assert candidate('abbaaba') == 'ABBAABA'
assert candidate('bbaaabaa') == 'BBAAABAA'
assert candidate('baaab') == 'BAAAB'
assert candidate('abaaaaab') == 'ABAAAAAB'
assert candidate('bababbaaa') == 'BABABBAAA'
assert candidate('bb') == 'BB'
# hidden tests
assert candidate('abaaabbb') == 'ABAAABBB'
assert candidate('aa') == 'AA'
assert candidate('babbaabb') == 'BABBAABB'
assert candidate('babaaa') == 'BABAAA'
assert candidate('ab') == 'AB'
assert candidate('aabbbbbbb') == 'AABBBBBBB'
assert candidate('baabbaabb') == 'BAABBAABB'
assert candidate('baabaaab') == 'BAABAAAB'
assert candidate('aabba') == 'AABBA'
assert candidate('b') == 'B'
assert candidate('abaababbbb') == 'ABAABABBBB'
assert candidate('aaaabbbb') == 'AAAABBBB'
assert candidate('aaa') == 'AAA'
assert candidate('aa') == 'AA'
assert candidate('aabbaaaa') == 'AABBAAAA'
assert candidate('a') == 'A'
assert candidate('b') == 'B'
assert candidate('bbba') == 'BBBA'
assert candidate('aaaaababaa') == 'AAAAABABAA'
assert candidate('abaaababba') == 'ABAAABABBA'
assert candidate('abbabbb') == 'ABBABBB'
assert candidate('aaaabaa') == 'AAAABAA'
assert candidate('aaabaaa') == 'AAABAAA'
assert candidate('abbbab') == 'ABBBAB'
assert candidate('aab') == 'AAB'
assert candidate('a') == 'A'
assert candidate('ababbb') == 'ABABBB'
assert candidate('b') == 'B'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('aaaaabaa') == 'AAAAABAA'
assert candidate('aaaabbaab') == 'AAAABBAAB'
assert candidate('aba') == 'ABA'
| 40
|
[
{
"input": "bbaabb",
"output": "BBAABB"
},
{
"input": "bbabaa",
"output": "BBABAA"
},
{
"input": "abbaaba",
"output": "ABBAABA"
},
{
"input": "bbaaabaa",
"output": "BBAAABAA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "abaaaaab",
"output": "ABAAAAAB"
},
{
"input": "bababbaaa",
"output": "BABABBAAA"
},
{
"input": "bb",
"output": "BB"
}
] |
[
{
"input": "abaaabbb",
"output": "ABAAABBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babbaabb",
"output": "BABBAABB"
},
{
"input": "babaaa",
"output": "BABAAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aabbbbbbb",
"output": "AABBBBBBB"
},
{
"input": "baabbaabb",
"output": "BAABBAABB"
},
{
"input": "baabaaab",
"output": "BAABAAAB"
},
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "abaababbbb",
"output": "ABAABABBBB"
},
{
"input": "aaaabbbb",
"output": "AAAABBBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabbaaaa",
"output": "AABBAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "aaaaababaa",
"output": "AAAAABABAA"
},
{
"input": "abaaababba",
"output": "ABAAABABBA"
},
{
"input": "abbabbb",
"output": "ABBABBB"
},
{
"input": "aaaabaa",
"output": "AAAABAA"
},
{
"input": "aaabaaa",
"output": "AAABAAA"
},
{
"input": "abbbab",
"output": "ABBBAB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababbb",
"output": "ABABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "aaaaabaa",
"output": "AAAAABAA"
},
{
"input": "aaaabbaab",
"output": "AAAABBAAB"
},
{
"input": "aba",
"output": "ABA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000045
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bababb') == 'bababb'
>>> apply_pipeline('aababbb') == 'aababbb'
>>> apply_pipeline('abba') == 'abba'
>>> apply_pipeline('aabba') == 'aabba'
>>> apply_pipeline('bbabbba') == 'bbabbba'
>>> apply_pipeline('baaab') == 'baaab'
>>> apply_pipeline('abbabbbb') == 'abbabbbb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ba') == 'ba'
assert candidate('bababb') == 'bababb'
assert candidate('aababbb') == 'aababbb'
assert candidate('abba') == 'abba'
assert candidate('aabba') == 'aabba'
assert candidate('bbabbba') == 'bbabbba'
assert candidate('baaab') == 'baaab'
assert candidate('abbabbbb') == 'abbabbbb'
# hidden tests
assert candidate('aaaa') == 'aaaa'
assert candidate('baaabaaabb') == 'baaabaaabb'
assert candidate('aa') == 'aa'
assert candidate('abbaabab') == 'abbaabab'
assert candidate('ababbbbaaa') == 'ababbbbaaa'
assert candidate('bbab') == 'bbab'
assert candidate('aaabababa') == 'aaabababa'
assert candidate('aabababa') == 'aabababa'
assert candidate('abaaabbbb') == 'abaaabbbb'
assert candidate('ab') == 'ab'
assert candidate('aabbaa') == 'aabbaa'
assert candidate('bab') == 'bab'
assert candidate('baaabb') == 'baaabb'
assert candidate('aaba') == 'aaba'
assert candidate('aba') == 'aba'
assert candidate('bbbbbba') == 'bbbbbba'
assert candidate('bbabaab') == 'bbabaab'
assert candidate('aba') == 'aba'
assert candidate('bb') == 'bb'
assert candidate('baa') == 'baa'
assert candidate('aaababab') == 'aaababab'
assert candidate('aaab') == 'aaab'
assert candidate('baaaababa') == 'baaaababa'
assert candidate('b') == 'b'
assert candidate('aaab') == 'aaab'
assert candidate('bb') == 'bb'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('baaa') == 'baaa'
assert candidate('aabbbb') == 'aabbbb'
assert candidate('bba') == 'bba'
assert candidate('babbaa') == 'babbaa'
assert candidate('abbbaaabb') == 'abbbaaabb'
| 40
|
[
{
"input": "ba",
"output": "ba"
},
{
"input": "bababb",
"output": "bababb"
},
{
"input": "aababbb",
"output": "aababbb"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "bbabbba",
"output": "bbabbba"
},
{
"input": "baaab",
"output": "baaab"
},
{
"input": "abbabbbb",
"output": "abbabbbb"
}
] |
[
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "baaabaaabb",
"output": "baaabaaabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "abbaabab",
"output": "abbaabab"
},
{
"input": "ababbbbaaa",
"output": "ababbbbaaa"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaabababa",
"output": "aaabababa"
},
{
"input": "aabababa",
"output": "aabababa"
},
{
"input": "abaaabbbb",
"output": "abaaabbbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aabbaa",
"output": "aabbaa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "baaabb",
"output": "baaabb"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbbbba",
"output": "bbbbbba"
},
{
"input": "bbabaab",
"output": "bbabaab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "aaababab",
"output": "aaababab"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "baaaababa",
"output": "baaaababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "aabbbb",
"output": "aabbbb"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "babbaa",
"output": "babbaa"
},
{
"input": "abbbaaabb",
"output": "abbbaaabb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000046
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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') == 'AAAAAAAA'
>>> apply_pipeline('bababaab') == 'AAAAAAAAAAAAAAAA'
>>> apply_pipeline('aabaababab') == 'AAAAAAAAAAAAAAAAAA'
>>> apply_pipeline('ba') == 'AAAA'
>>> apply_pipeline('bbaabba') == 'AAAAAAAAAAAAAAA'
>>> apply_pipeline('bbbbbaba') == 'AAAAAAAAAAAAAAAAAAAA'
>>> apply_pipeline('baba') == 'AAAAAAAA'
>>> apply_pipeline('bbbbb') == 'AAAAAAAAAAAAAAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
s = s.replace('B', 'aaa')
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"B",
"aaa"
]
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baab') == 'AAAAAAAA'
assert candidate('bababaab') == 'AAAAAAAAAAAAAAAA'
assert candidate('aabaababab') == 'AAAAAAAAAAAAAAAAAA'
assert candidate('ba') == 'AAAA'
assert candidate('bbaabba') == 'AAAAAAAAAAAAAAA'
assert candidate('bbbbbaba') == 'AAAAAAAAAAAAAAAAAAAA'
assert candidate('baba') == 'AAAAAAAA'
assert candidate('bbbbb') == 'AAAAAAAAAAAAAAA'
# hidden tests
assert candidate('aababaaaab') == 'AAAAAAAAAAAAAAAA'
assert candidate('babb') == 'AAAAAAAAAA'
assert candidate('a') == 'A'
assert candidate('bbbbaba') == 'AAAAAAAAAAAAAAAAA'
assert candidate('bbabbbaba') == 'AAAAAAAAAAAAAAAAAAAAA'
assert candidate('bbabbbbaa') == 'AAAAAAAAAAAAAAAAAAAAA'
assert candidate('a') == 'A'
assert candidate('aa') == 'AA'
assert candidate('aab') == 'AAAAA'
assert candidate('aabba') == 'AAAAAAAAA'
assert candidate('aaabaaaaaa') == 'AAAAAAAAAAAA'
assert candidate('baaa') == 'AAAAAA'
assert candidate('bbaaab') == 'AAAAAAAAAAAA'
assert candidate('baabb') == 'AAAAAAAAAAA'
assert candidate('aaaa') == 'AAAA'
assert candidate('ababa') == 'AAAAAAAAA'
assert candidate('a') == 'A'
assert candidate('aaabba') == 'AAAAAAAAAA'
assert candidate('abb') == 'AAAAAAA'
assert candidate('bbaaaaabba') == 'AAAAAAAAAAAAAAAAAA'
assert candidate('bb') == 'AAAAAA'
assert candidate('bbaaa') == 'AAAAAAAAA'
assert candidate('abaabba') == 'AAAAAAAAAAAAA'
assert candidate('aabbaaabba') == 'AAAAAAAAAAAAAAAAAA'
assert candidate('abbbbab') == 'AAAAAAAAAAAAAAAAA'
assert candidate('baaab') == 'AAAAAAAAA'
assert candidate('ba') == 'AAAA'
assert candidate('a') == 'A'
assert candidate('abbabaaaaa') == 'AAAAAAAAAAAAAAAA'
assert candidate('abbaba') == 'AAAAAAAAAAAA'
assert candidate('aaaab') == 'AAAAAAA'
assert candidate('abbb') == 'AAAAAAAAAA'
| 40
|
[
{
"input": "baab",
"output": "AAAAAAAA"
},
{
"input": "bababaab",
"output": "AAAAAAAAAAAAAAAA"
},
{
"input": "aabaababab",
"output": "AAAAAAAAAAAAAAAAAA"
},
{
"input": "ba",
"output": "AAAA"
},
{
"input": "bbaabba",
"output": "AAAAAAAAAAAAAAA"
},
{
"input": "bbbbbaba",
"output": "AAAAAAAAAAAAAAAAAAAA"
},
{
"input": "baba",
"output": "AAAAAAAA"
},
{
"input": "bbbbb",
"output": "AAAAAAAAAAAAAAA"
}
] |
[
{
"input": "aababaaaab",
"output": "AAAAAAAAAAAAAAAA"
},
{
"input": "babb",
"output": "AAAAAAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbbaba",
"output": "AAAAAAAAAAAAAAAAA"
},
{
"input": "bbabbbaba",
"output": "AAAAAAAAAAAAAAAAAAAAA"
},
{
"input": "bbabbbbaa",
"output": "AAAAAAAAAAAAAAAAAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aab",
"output": "AAAAA"
},
{
"input": "aabba",
"output": "AAAAAAAAA"
},
{
"input": "aaabaaaaaa",
"output": "AAAAAAAAAAAA"
},
{
"input": "baaa",
"output": "AAAAAA"
},
{
"input": "bbaaab",
"output": "AAAAAAAAAAAA"
},
{
"input": "baabb",
"output": "AAAAAAAAAAA"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "ababa",
"output": "AAAAAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabba",
"output": "AAAAAAAAAA"
},
{
"input": "abb",
"output": "AAAAAAA"
},
{
"input": "bbaaaaabba",
"output": "AAAAAAAAAAAAAAAAAA"
},
{
"input": "bb",
"output": "AAAAAA"
},
{
"input": "bbaaa",
"output": "AAAAAAAAA"
},
{
"input": "abaabba",
"output": "AAAAAAAAAAAAA"
},
{
"input": "aabbaaabba",
"output": "AAAAAAAAAAAAAAAAAA"
},
{
"input": "abbbbab",
"output": "AAAAAAAAAAAAAAAAA"
},
{
"input": "baaab",
"output": "AAAAAAAAA"
},
{
"input": "ba",
"output": "AAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "abbabaaaaa",
"output": "AAAAAAAAAAAAAAAA"
},
{
"input": "abbaba",
"output": "AAAAAAAAAAAA"
},
{
"input": "aaaab",
"output": "AAAAAAA"
},
{
"input": "abbb",
"output": "AAAAAAAAAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000047
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaabbb') == 'aaabbb'
>>> apply_pipeline('baaaabba') == 'bbaaabbb'
>>> apply_pipeline('aaabba') == 'aaabbb'
>>> apply_pipeline('baaa') == 'bbaa'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('bba') == 'bbb'
>>> apply_pipeline('aaabb') == 'aaabb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.replace('ba', 'bb')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"ba",
"bb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabbb') == 'aaabbb'
assert candidate('baaaabba') == 'bbaaabbb'
assert candidate('aaabba') == 'aaabbb'
assert candidate('baaa') == 'bbaa'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('bba') == 'bbb'
assert candidate('aaabb') == 'aaabb'
# hidden tests
assert candidate('aab') == 'aab'
assert candidate('abbbbabaa') == 'abbbbbbba'
assert candidate('bbbab') == 'bbbbb'
assert candidate('bbaabbbaba') == 'bbbabbbbbb'
assert candidate('abbaabb') == 'abbbabb'
assert candidate('aa') == 'aa'
assert candidate('babbbbaabb') == 'bbbbbbbabb'
assert candidate('baaa') == 'bbaa'
assert candidate('abbabbba') == 'abbbbbbb'
assert candidate('abbba') == 'abbbb'
assert candidate('abbabbbb') == 'abbbbbbb'
assert candidate('bababab') == 'bbbbbbb'
assert candidate('abaaa') == 'abbaa'
assert candidate('baaabbab') == 'bbaabbbb'
assert candidate('bababbbab') == 'bbbbbbbbb'
assert candidate('a') == 'a'
assert candidate('bbba') == 'bbbb'
assert candidate('abbb') == 'abbb'
assert candidate('abba') == 'abbb'
assert candidate('aaabbbbaa') == 'aaabbbbba'
assert candidate('bbbababba') == 'bbbbbbbbb'
assert candidate('bababbabba') == 'bbbbbbbbbb'
assert candidate('aaaba') == 'aaabb'
assert candidate('babba') == 'bbbbb'
assert candidate('baaaaba') == 'bbaaabb'
assert candidate('abaaaabaab') == 'abbaaabbab'
assert candidate('aababa') == 'aabbbb'
assert candidate('bbbabbaaa') == 'bbbbbbbaa'
assert candidate('aaabbaabbb') == 'aaabbbabbb'
assert candidate('abaabbaa') == 'abbabbba'
assert candidate('bababa') == 'bbbbbb'
assert candidate('a') == 'a'
| 40
|
[
{
"input": "aaabbb",
"output": "aaabbb"
},
{
"input": "baaaabba",
"output": "bbaaabbb"
},
{
"input": "aaabba",
"output": "aaabbb"
},
{
"input": "baaa",
"output": "bbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "bba",
"output": "bbb"
},
{
"input": "aaabb",
"output": "aaabb"
}
] |
[
{
"input": "aab",
"output": "aab"
},
{
"input": "abbbbabaa",
"output": "abbbbbbba"
},
{
"input": "bbbab",
"output": "bbbbb"
},
{
"input": "bbaabbbaba",
"output": "bbbabbbbbb"
},
{
"input": "abbaabb",
"output": "abbbabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "babbbbaabb",
"output": "bbbbbbbabb"
},
{
"input": "baaa",
"output": "bbaa"
},
{
"input": "abbabbba",
"output": "abbbbbbb"
},
{
"input": "abbba",
"output": "abbbb"
},
{
"input": "abbabbbb",
"output": "abbbbbbb"
},
{
"input": "bababab",
"output": "bbbbbbb"
},
{
"input": "abaaa",
"output": "abbaa"
},
{
"input": "baaabbab",
"output": "bbaabbbb"
},
{
"input": "bababbbab",
"output": "bbbbbbbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbba",
"output": "bbbb"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "abba",
"output": "abbb"
},
{
"input": "aaabbbbaa",
"output": "aaabbbbba"
},
{
"input": "bbbababba",
"output": "bbbbbbbbb"
},
{
"input": "bababbabba",
"output": "bbbbbbbbbb"
},
{
"input": "aaaba",
"output": "aaabb"
},
{
"input": "babba",
"output": "bbbbb"
},
{
"input": "baaaaba",
"output": "bbaaabb"
},
{
"input": "abaaaabaab",
"output": "abbaaabbab"
},
{
"input": "aababa",
"output": "aabbbb"
},
{
"input": "bbbabbaaa",
"output": "bbbbbbbaa"
},
{
"input": "aaabbaabbb",
"output": "aaabbbabbb"
},
{
"input": "abaabbaa",
"output": "abbabbba"
},
{
"input": "bababa",
"output": "bbbbbb"
},
{
"input": "a",
"output": "a"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000048
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('ababaabab') == 'ABABAABAB'
>>> apply_pipeline('babaaaa') == 'BABAAAA'
>>> apply_pipeline('abbbbaaa') == 'ABBBBAAA'
>>> apply_pipeline('babbaabab') == 'BABBAABAB'
>>> apply_pipeline('aaabbaaabb') == 'AAABBAAABB'
>>> apply_pipeline('bbbbba') == 'BBBBBA'
>>> apply_pipeline('aaaabaaba') == 'AAAABAABA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbab') == 'BBAB'
assert candidate('ababaabab') == 'ABABAABAB'
assert candidate('babaaaa') == 'BABAAAA'
assert candidate('abbbbaaa') == 'ABBBBAAA'
assert candidate('babbaabab') == 'BABBAABAB'
assert candidate('aaabbaaabb') == 'AAABBAAABB'
assert candidate('bbbbba') == 'BBBBBA'
assert candidate('aaaabaaba') == 'AAAABAABA'
# hidden tests
assert candidate('baabbbbaa') == 'BAABBBBAA'
assert candidate('abaaa') == 'ABAAA'
assert candidate('baab') == 'BAAB'
assert candidate('babbaab') == 'BABBAAB'
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('bbabbbab') == 'BBABBBAB'
assert candidate('b') == 'B'
assert candidate('bbba') == 'BBBA'
assert candidate('baa') == 'BAA'
assert candidate('bbba') == 'BBBA'
assert candidate('a') == 'A'
assert candidate('bbaaabba') == 'BBAAABBA'
assert candidate('baaa') == 'BAAA'
assert candidate('baa') == 'BAA'
assert candidate('baabaabab') == 'BAABAABAB'
assert candidate('bbbab') == 'BBBAB'
assert candidate('babbaaba') == 'BABBAABA'
assert candidate('b') == 'B'
assert candidate('baababa') == 'BAABABA'
assert candidate('aababbba') == 'AABABBBA'
assert candidate('aabab') == 'AABAB'
assert candidate('aabbbb') == 'AABBBB'
assert candidate('bbaababbaa') == 'BBAABABBAA'
assert candidate('aaabb') == 'AAABB'
assert candidate('abaaa') == 'ABAAA'
assert candidate('aaa') == 'AAA'
assert candidate('bbaaabbbab') == 'BBAAABBBAB'
assert candidate('aabbababb') == 'AABBABABB'
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('a') == 'A'
assert candidate('bbbaabbaba') == 'BBBAABBABA'
assert candidate('aaaabaaaaa') == 'AAAABAAAAA'
| 40
|
[
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "ababaabab",
"output": "ABABAABAB"
},
{
"input": "babaaaa",
"output": "BABAAAA"
},
{
"input": "abbbbaaa",
"output": "ABBBBAAA"
},
{
"input": "babbaabab",
"output": "BABBAABAB"
},
{
"input": "aaabbaaabb",
"output": "AAABBAAABB"
},
{
"input": "bbbbba",
"output": "BBBBBA"
},
{
"input": "aaaabaaba",
"output": "AAAABAABA"
}
] |
[
{
"input": "baabbbbaa",
"output": "BAABBBBAA"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "babbaab",
"output": "BABBAAB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "bbabbbab",
"output": "BBABBBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbaaabba",
"output": "BBAAABBA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "baabaabab",
"output": "BAABAABAB"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "babbaaba",
"output": "BABBAABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "baababa",
"output": "BAABABA"
},
{
"input": "aababbba",
"output": "AABABBBA"
},
{
"input": "aabab",
"output": "AABAB"
},
{
"input": "aabbbb",
"output": "AABBBB"
},
{
"input": "bbaababbaa",
"output": "BBAABABBAA"
},
{
"input": "aaabb",
"output": "AAABB"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "bbaaabbbab",
"output": "BBAAABBBAB"
},
{
"input": "aabbababb",
"output": "AABBABABB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbaabbaba",
"output": "BBBAABBABA"
},
{
"input": "aaaabaaaaa",
"output": "AAAABAAAAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000049
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbaaaaaa') == 'ABBAAAAAA'
>>> apply_pipeline('bb') == 'BB'
>>> apply_pipeline('bbaabbbbaa') == 'BBAABBBBAA'
>>> apply_pipeline('baabbba') == 'BAABBBA'
>>> apply_pipeline('bababaa') == 'BABABAA'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('bbbabbbbb') == 'BBBABBBBB'
>>> apply_pipeline('bbbbaa') == 'BBBBAA'
"""
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('abbaaaaaa') == 'ABBAAAAAA'
assert candidate('bb') == 'BB'
assert candidate('bbaabbbbaa') == 'BBAABBBBAA'
assert candidate('baabbba') == 'BAABBBA'
assert candidate('bababaa') == 'BABABAA'
assert candidate('aa') == 'AA'
assert candidate('bbbabbbbb') == 'BBBABBBBB'
assert candidate('bbbbaa') == 'BBBBAA'
# hidden tests
assert candidate('ab') == 'AB'
assert candidate('bbabbba') == 'BBABBBA'
assert candidate('aabbbbbab') == 'AABBBBBAB'
assert candidate('aaabbaba') == 'AAABBABA'
assert candidate('a') == 'A'
assert candidate('aaabbbaaaa') == 'AAABBBAAAA'
assert candidate('baaabbbaaa') == 'BAAABBBAAA'
assert candidate('aabbba') == 'AABBBA'
assert candidate('abbaa') == 'ABBAA'
assert candidate('baaa') == 'BAAA'
assert candidate('aaab') == 'AAAB'
assert candidate('a') == 'A'
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('baaab') == 'BAAAB'
assert candidate('babbba') == 'BABBBA'
assert candidate('abbbaaa') == 'ABBBAAA'
assert candidate('aa') == 'AA'
assert candidate('baaaaba') == 'BAAAABA'
assert candidate('bbb') == 'BBB'
assert candidate('aaababbb') == 'AAABABBB'
assert candidate('abaabaab') == 'ABAABAAB'
assert candidate('b') == 'B'
assert candidate('bababaabba') == 'BABABAABBA'
assert candidate('bba') == 'BBA'
assert candidate('bbabbba') == 'BBABBBA'
assert candidate('abaaaa') == 'ABAAAA'
assert candidate('abbbbab') == 'ABBBBAB'
assert candidate('bbbbaaabba') == 'BBBBAAABBA'
assert candidate('babba') == 'BABBA'
assert candidate('aabbb') == 'AABBB'
assert candidate('aaab') == 'AAAB'
assert candidate('aaaaaab') == 'AAAAAAB'
| 40
|
[
{
"input": "abbaaaaaa",
"output": "ABBAAAAAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbaabbbbaa",
"output": "BBAABBBBAA"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbbabbbbb",
"output": "BBBABBBBB"
},
{
"input": "bbbbaa",
"output": "BBBBAA"
}
] |
[
{
"input": "ab",
"output": "AB"
},
{
"input": "bbabbba",
"output": "BBABBBA"
},
{
"input": "aabbbbbab",
"output": "AABBBBBAB"
},
{
"input": "aaabbaba",
"output": "AAABBABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabbbaaaa",
"output": "AAABBBAAAA"
},
{
"input": "baaabbbaaa",
"output": "BAAABBBAAA"
},
{
"input": "aabbba",
"output": "AABBBA"
},
{
"input": "abbaa",
"output": "ABBAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "babbba",
"output": "BABBBA"
},
{
"input": "abbbaaa",
"output": "ABBBAAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baaaaba",
"output": "BAAAABA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aaababbb",
"output": "AAABABBB"
},
{
"input": "abaabaab",
"output": "ABAABAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababaabba",
"output": "BABABAABBA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "bbabbba",
"output": "BBABBBA"
},
{
"input": "abaaaa",
"output": "ABAAAA"
},
{
"input": "abbbbab",
"output": "ABBBBAB"
},
{
"input": "bbbbaaabba",
"output": "BBBBAAABBA"
},
{
"input": "babba",
"output": "BABBA"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "aaaaaab",
"output": "AAAAAAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000050
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babababbb') == 'babababbb'
>>> apply_pipeline('bbbb') == 'bbbb'
>>> apply_pipeline('babba') == 'babba'
>>> apply_pipeline('aab') == 'aab'
>>> apply_pipeline('ba') == 'ba'
>>> apply_pipeline('baaa') == 'baaa'
>>> apply_pipeline('baab') == 'baab'
>>> apply_pipeline('aab') == 'aab'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aaba', 'bbbb')
return s
|
[
{
"method": "replace",
"args": [
"aaba",
"bbbb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babababbb') == 'babababbb'
assert candidate('bbbb') == 'bbbb'
assert candidate('babba') == 'babba'
assert candidate('aab') == 'aab'
assert candidate('ba') == 'ba'
assert candidate('baaa') == 'baaa'
assert candidate('baab') == 'baab'
assert candidate('aab') == 'aab'
# hidden tests
assert candidate('bab') == 'bab'
assert candidate('bbabbbbaa') == 'bbabbbbaa'
assert candidate('aabbaaab') == 'aabbaaab'
assert candidate('ab') == 'ab'
assert candidate('ababbbbba') == 'ababbbbba'
assert candidate('aaabaab') == 'abbbbab'
assert candidate('ba') == 'ba'
assert candidate('aab') == 'aab'
assert candidate('aabbbbabbb') == 'aabbbbabbb'
assert candidate('bbabbbbbaa') == 'bbabbbbbaa'
assert candidate('ababababb') == 'ababababb'
assert candidate('abbbababbb') == 'abbbababbb'
assert candidate('aaab') == 'aaab'
assert candidate('aaabaaa') == 'abbbbaa'
assert candidate('abaaabaaab') == 'ababbbbaab'
assert candidate('b') == 'b'
assert candidate('aaabaab') == 'abbbbab'
assert candidate('aba') == 'aba'
assert candidate('bbbb') == 'bbbb'
assert candidate('a') == 'a'
assert candidate('abbbbb') == 'abbbbb'
assert candidate('aabbbabba') == 'aabbbabba'
assert candidate('aa') == 'aa'
assert candidate('bb') == 'bb'
assert candidate('abbaba') == 'abbaba'
assert candidate('ba') == 'ba'
assert candidate('bbbabbaaa') == 'bbbabbaaa'
assert candidate('abbaa') == 'abbaa'
assert candidate('aba') == 'aba'
assert candidate('bbab') == 'bbab'
assert candidate('aabbbaa') == 'aabbbaa'
assert candidate('bbbb') == 'bbbb'
| 40
|
[
{
"input": "babababbb",
"output": "babababbb"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "babba",
"output": "babba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "aab",
"output": "aab"
}
] |
[
{
"input": "bab",
"output": "bab"
},
{
"input": "bbabbbbaa",
"output": "bbabbbbaa"
},
{
"input": "aabbaaab",
"output": "aabbaaab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ababbbbba",
"output": "ababbbbba"
},
{
"input": "aaabaab",
"output": "abbbbab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "aabbbbabbb",
"output": "aabbbbabbb"
},
{
"input": "bbabbbbbaa",
"output": "bbabbbbbaa"
},
{
"input": "ababababb",
"output": "ababababb"
},
{
"input": "abbbababbb",
"output": "abbbababbb"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "aaabaaa",
"output": "abbbbaa"
},
{
"input": "abaaabaaab",
"output": "ababbbbaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaabaab",
"output": "abbbbab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbbb",
"output": "abbbbb"
},
{
"input": "aabbbabba",
"output": "aabbbabba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abbaba",
"output": "abbaba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbbabbaaa",
"output": "bbbabbaaa"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aabbbaa",
"output": "aabbbaa"
},
{
"input": "bbbb",
"output": "bbbb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000051
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babaaa') == 'BABAAA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('baba') == 'BABA'
>>> apply_pipeline('bbbbbaabb') == 'BBBBBAABB'
>>> apply_pipeline('aabaa') == 'AABAA'
>>> apply_pipeline('abaaab') == 'ABAAAB'
>>> apply_pipeline('abbbaaabb') == 'ABBBAAABB'
>>> apply_pipeline('baabb') == 'BAABB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaaa') == 'BABAAA'
assert candidate('a') == 'A'
assert candidate('baba') == 'BABA'
assert candidate('bbbbbaabb') == 'BBBBBAABB'
assert candidate('aabaa') == 'AABAA'
assert candidate('abaaab') == 'ABAAAB'
assert candidate('abbbaaabb') == 'ABBBAAABB'
assert candidate('baabb') == 'BAABB'
# hidden tests
assert candidate('abbab') == 'ABBAB'
assert candidate('bbaaabaa') == 'BBAAABAA'
assert candidate('ba') == 'BA'
assert candidate('ba') == 'BA'
assert candidate('abaababbba') == 'ABAABABBBA'
assert candidate('ab') == 'AB'
assert candidate('abaabbbba') == 'ABAABBBBA'
assert candidate('babaab') == 'BABAAB'
assert candidate('aaabbaaaba') == 'AAABBAAABA'
assert candidate('a') == 'A'
assert candidate('aabb') == 'AABB'
assert candidate('abaaba') == 'ABAABA'
assert candidate('ba') == 'BA'
assert candidate('b') == 'B'
assert candidate('baababb') == 'BAABABB'
assert candidate('aaabbaaaaa') == 'AAABBAAAAA'
assert candidate('baa') == 'BAA'
assert candidate('aaaaab') == 'AAAAAB'
assert candidate('aaaaaaa') == 'AAAAAAA'
assert candidate('baaaa') == 'BAAAA'
assert candidate('abab') == 'ABAB'
assert candidate('aa') == 'AA'
assert candidate('bbbb') == 'BBBB'
assert candidate('aababb') == 'AABABB'
assert candidate('bbaab') == 'BBAAB'
assert candidate('bbabaababb') == 'BBABAABABB'
assert candidate('abbababb') == 'ABBABABB'
assert candidate('ba') == 'BA'
assert candidate('bbbabbb') == 'BBBABBB'
assert candidate('baa') == 'BAA'
assert candidate('bbbabbbaab') == 'BBBABBBAAB'
assert candidate('babbbbbbab') == 'BABBBBBBAB'
| 40
|
[
{
"input": "babaaa",
"output": "BABAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "bbbbbaabb",
"output": "BBBBBAABB"
},
{
"input": "aabaa",
"output": "AABAA"
},
{
"input": "abaaab",
"output": "ABAAAB"
},
{
"input": "abbbaaabb",
"output": "ABBBAAABB"
},
{
"input": "baabb",
"output": "BAABB"
}
] |
[
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "bbaaabaa",
"output": "BBAAABAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "abaababbba",
"output": "ABAABABBBA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abaabbbba",
"output": "ABAABBBBA"
},
{
"input": "babaab",
"output": "BABAAB"
},
{
"input": "aaabbaaaba",
"output": "AAABBAAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "b",
"output": "B"
},
{
"input": "baababb",
"output": "BAABABB"
},
{
"input": "aaabbaaaaa",
"output": "AAABBAAAAA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "aaaaab",
"output": "AAAAAB"
},
{
"input": "aaaaaaa",
"output": "AAAAAAA"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "aababb",
"output": "AABABB"
},
{
"input": "bbaab",
"output": "BBAAB"
},
{
"input": "bbabaababb",
"output": "BBABAABABB"
},
{
"input": "abbababb",
"output": "ABBABABB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbbabbb",
"output": "BBBABBB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbbabbbaab",
"output": "BBBABBBAAB"
},
{
"input": "babbbbbbab",
"output": "BABBBBBBAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000052
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aba') == 'ABA'
>>> apply_pipeline('baabaa') == 'BAABAA'
>>> apply_pipeline('baabbb') == 'BAABBB'
>>> apply_pipeline('ababaab') == 'ABABAAB'
>>> apply_pipeline('baaabaa') == 'BAAABAA'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('aab') == 'AAB'
>>> apply_pipeline('aaababa') == 'AAABABA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aba') == 'ABA'
assert candidate('baabaa') == 'BAABAA'
assert candidate('baabbb') == 'BAABBB'
assert candidate('ababaab') == 'ABABAAB'
assert candidate('baaabaa') == 'BAAABAA'
assert candidate('bbb') == 'BBB'
assert candidate('aab') == 'AAB'
assert candidate('aaababa') == 'AAABABA'
# hidden tests
assert candidate('aaaaabb') == 'AAAAABB'
assert candidate('ababaaaabb') == 'ABABAAAABB'
assert candidate('a') == 'A'
assert candidate('abab') == 'ABAB'
assert candidate('b') == 'B'
assert candidate('bababbbbab') == 'BABABBBBAB'
assert candidate('bba') == 'BBA'
assert candidate('a') == 'A'
assert candidate('bbabbb') == 'BBABBB'
assert candidate('bbaaaba') == 'BBAAABA'
assert candidate('bbbbbabbba') == 'BBBBBABBBA'
assert candidate('bab') == 'BAB'
assert candidate('bba') == 'BBA'
assert candidate('bbabba') == 'BBABBA'
assert candidate('aaabbaaa') == 'AAABBAAA'
assert candidate('bababaa') == 'BABABAA'
assert candidate('b') == 'B'
assert candidate('ababaaa') == 'ABABAAA'
assert candidate('baaaabaa') == 'BAAAABAA'
assert candidate('aaaa') == 'AAAA'
assert candidate('ababbbaab') == 'ABABBBAAB'
assert candidate('baabaabbaa') == 'BAABAABBAA'
assert candidate('aaabab') == 'AAABAB'
assert candidate('bbaa') == 'BBAA'
assert candidate('aabbabbab') == 'AABBABBAB'
assert candidate('aaaaaabab') == 'AAAAAABAB'
assert candidate('ababaa') == 'ABABAA'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('aaa') == 'AAA'
assert candidate('aababbaab') == 'AABABBAAB'
assert candidate('aaaabbaba') == 'AAAABBABA'
assert candidate('bbbbbb') == 'BBBBBB'
| 40
|
[
{
"input": "aba",
"output": "ABA"
},
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "baabbb",
"output": "BAABBB"
},
{
"input": "ababaab",
"output": "ABABAAB"
},
{
"input": "baaabaa",
"output": "BAAABAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "aaababa",
"output": "AAABABA"
}
] |
[
{
"input": "aaaaabb",
"output": "AAAAABB"
},
{
"input": "ababaaaabb",
"output": "ABABAAAABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababbbbab",
"output": "BABABBBBAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbabbb",
"output": "BBABBB"
},
{
"input": "bbaaaba",
"output": "BBAAABA"
},
{
"input": "bbbbbabbba",
"output": "BBBBBABBBA"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "bbabba",
"output": "BBABBA"
},
{
"input": "aaabbaaa",
"output": "AAABBAAA"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ababaaa",
"output": "ABABAAA"
},
{
"input": "baaaabaa",
"output": "BAAAABAA"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "ababbbaab",
"output": "ABABBBAAB"
},
{
"input": "baabaabbaa",
"output": "BAABAABBAA"
},
{
"input": "aaabab",
"output": "AAABAB"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "aabbabbab",
"output": "AABBABBAB"
},
{
"input": "aaaaaabab",
"output": "AAAAAABAB"
},
{
"input": "ababaa",
"output": "ABABAA"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aababbaab",
"output": "AABABBAAB"
},
{
"input": "aaaabbaba",
"output": "AAAABBABA"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000053
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaa') == 'aaabaabb'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('aababb') == 'aaabaaab'
>>> apply_pipeline('aba') == 'aaabb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('abbbbbabab') == 'aaabaaabaabbb'
>>> apply_pipeline('bbaabb') == 'aaabaabbb'
>>> apply_pipeline('abaabaabb') == 'aaabaaabaaabb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('a', 'bbb')
s = s.replace('bbb', 'aabb')
s = s.lower()
s = s.replace('bbaab', 'a')
return s
|
[
{
"method": "replace",
"args": [
"a",
"bbb"
]
},
{
"method": "replace",
"args": [
"bbb",
"aabb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bbaab",
"a"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaa') == 'aaabaabb'
assert candidate('bb') == 'bb'
assert candidate('aababb') == 'aaabaaab'
assert candidate('aba') == 'aaabb'
assert candidate('b') == 'b'
assert candidate('abbbbbabab') == 'aaabaaabaabbb'
assert candidate('bbaabb') == 'aaabaabbb'
assert candidate('abaabaabb') == 'aaabaaabaaabb'
# hidden tests
assert candidate('aabb') == 'aaabbb'
assert candidate('babbbabaa') == 'aaabaaabaabbbb'
assert candidate('aba') == 'aaabb'
assert candidate('baaabbbba') == 'aaabaaabaabbbb'
assert candidate('aababaaa') == 'aaabaaabaaabbb'
assert candidate('a') == 'aabb'
assert candidate('baaaaaab') == 'aaabaaabaaabbb'
assert candidate('bbbaabb') == 'aaabaabbbb'
assert candidate('ba') == 'aabbb'
assert candidate('bbabaaaa') == 'aaabaaabaaab'
assert candidate('ba') == 'aabbb'
assert candidate('babbbab') == 'aaabaabbbb'
assert candidate('abaababb') == 'aaabaaabaabbb'
assert candidate('aabbbb') == 'aaabaabbb'
assert candidate('bbbbbba') == 'aaabaabb'
assert candidate('bbb') == 'aabb'
assert candidate('ab') == 'aabbb'
assert candidate('abababb') == 'aaabaaabb'
assert candidate('baaabab') == 'aaabaaabaabb'
assert candidate('baababa') == 'aaabaaabaabb'
assert candidate('baaaa') == 'aaabaaabb'
assert candidate('bbaaa') == 'aaabaabbbb'
assert candidate('bbba') == 'aaab'
assert candidate('bbbab') == 'aaabb'
assert candidate('ba') == 'aabbb'
assert candidate('aaaaabba') == 'aaabaaabaaabbb'
assert candidate('abaa') == 'aaabaabbb'
assert candidate('bbabbbbaba') == 'aaabaaabaabbb'
assert candidate('aabaaaa') == 'aaabaaabaaabb'
assert candidate('aaa') == 'aaabaabb'
assert candidate('bbabbaaab') == 'aaabaaabaabbbb'
assert candidate('baabbaab') == 'aaabaaabaabbb'
| 40
|
[
{
"input": "aaa",
"output": "aaabaabb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aababb",
"output": "aaabaaab"
},
{
"input": "aba",
"output": "aaabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbbbbabab",
"output": "aaabaaabaabbb"
},
{
"input": "bbaabb",
"output": "aaabaabbb"
},
{
"input": "abaabaabb",
"output": "aaabaaabaaabb"
}
] |
[
{
"input": "aabb",
"output": "aaabbb"
},
{
"input": "babbbabaa",
"output": "aaabaaabaabbbb"
},
{
"input": "aba",
"output": "aaabb"
},
{
"input": "baaabbbba",
"output": "aaabaaabaabbbb"
},
{
"input": "aababaaa",
"output": "aaabaaabaaabbb"
},
{
"input": "a",
"output": "aabb"
},
{
"input": "baaaaaab",
"output": "aaabaaabaaabbb"
},
{
"input": "bbbaabb",
"output": "aaabaabbbb"
},
{
"input": "ba",
"output": "aabbb"
},
{
"input": "bbabaaaa",
"output": "aaabaaabaaab"
},
{
"input": "ba",
"output": "aabbb"
},
{
"input": "babbbab",
"output": "aaabaabbbb"
},
{
"input": "abaababb",
"output": "aaabaaabaabbb"
},
{
"input": "aabbbb",
"output": "aaabaabbb"
},
{
"input": "bbbbbba",
"output": "aaabaabb"
},
{
"input": "bbb",
"output": "aabb"
},
{
"input": "ab",
"output": "aabbb"
},
{
"input": "abababb",
"output": "aaabaaabb"
},
{
"input": "baaabab",
"output": "aaabaaabaabb"
},
{
"input": "baababa",
"output": "aaabaaabaabb"
},
{
"input": "baaaa",
"output": "aaabaaabb"
},
{
"input": "bbaaa",
"output": "aaabaabbbb"
},
{
"input": "bbba",
"output": "aaab"
},
{
"input": "bbbab",
"output": "aaabb"
},
{
"input": "ba",
"output": "aabbb"
},
{
"input": "aaaaabba",
"output": "aaabaaabaaabbb"
},
{
"input": "abaa",
"output": "aaabaabbb"
},
{
"input": "bbabbbbaba",
"output": "aaabaaabaabbb"
},
{
"input": "aabaaaa",
"output": "aaabaaabaaabb"
},
{
"input": "aaa",
"output": "aaabaabb"
},
{
"input": "bbabbaaab",
"output": "aaabaaabaabbbb"
},
{
"input": "baabbaab",
"output": "aaabaaabaabbb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000054
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('ab') == 'ab'
>>> apply_pipeline('aabbbbaa') == 'aabbbbaa'
>>> apply_pipeline('bbbaa') == 'bbbaa'
>>> apply_pipeline('babbaba') == 'babbaba'
>>> apply_pipeline('baaaabb') == 'baaaabb'
>>> apply_pipeline('ab') == 'ab'
>>> apply_pipeline('bbaaaba') == 'bbaaaba'
"""
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('b') == 'b'
assert candidate('ab') == 'ab'
assert candidate('aabbbbaa') == 'aabbbbaa'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('babbaba') == 'babbaba'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('ab') == 'ab'
assert candidate('bbaaaba') == 'bbaaaba'
# hidden tests
assert candidate('bbbabaa') == 'bbbabaa'
assert candidate('baaba') == 'baaba'
assert candidate('bab') == 'bab'
assert candidate('abaaaa') == 'abaaaa'
assert candidate('abaababbba') == 'abaababbba'
assert candidate('aabbaab') == 'aabbaab'
assert candidate('a') == 'a'
assert candidate('a') == 'a'
assert candidate('abaaaab') == 'abaaaab'
assert candidate('abbbba') == 'abbbba'
assert candidate('bbab') == 'bbab'
assert candidate('aaabbbab') == 'aaabbbab'
assert candidate('abbbaaa') == 'abbbaaa'
assert candidate('abab') == 'abab'
assert candidate('baabbbb') == 'baabbbb'
assert candidate('ababaaaaab') == 'ababaaaaab'
assert candidate('a') == 'a'
assert candidate('babaa') == 'babaa'
assert candidate('bbaababaa') == 'bbaababaa'
assert candidate('abba') == 'abba'
assert candidate('aaaaaaa') == 'aaaaaaa'
assert candidate('aabaabaaa') == 'aabaabaaa'
assert candidate('babaaa') == 'babaaa'
assert candidate('b') == 'b'
assert candidate('bbba') == 'bbba'
assert candidate('bbaa') == 'bbaa'
assert candidate('aaababbbb') == 'aaababbbb'
assert candidate('abaaaaba') == 'abaaaaba'
assert candidate('abba') == 'abba'
assert candidate('bbaaababab') == 'bbaaababab'
assert candidate('baabbbb') == 'baabbbb'
assert candidate('bb') == 'bb'
| 40
|
[
{
"input": "b",
"output": "b"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aabbbbaa",
"output": "aabbbbaa"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "babbaba",
"output": "babbaba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaaaba",
"output": "bbaaaba"
}
] |
[
{
"input": "bbbabaa",
"output": "bbbabaa"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abaaaa",
"output": "abaaaa"
},
{
"input": "abaababbba",
"output": "abaababbba"
},
{
"input": "aabbaab",
"output": "aabbaab"
},
{
"input": "a",
"output": "a"
},
{
"input": "a",
"output": "a"
},
{
"input": "abaaaab",
"output": "abaaaab"
},
{
"input": "abbbba",
"output": "abbbba"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaabbbab",
"output": "aaabbbab"
},
{
"input": "abbbaaa",
"output": "abbbaaa"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "baabbbb",
"output": "baabbbb"
},
{
"input": "ababaaaaab",
"output": "ababaaaaab"
},
{
"input": "a",
"output": "a"
},
{
"input": "babaa",
"output": "babaa"
},
{
"input": "bbaababaa",
"output": "bbaababaa"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "aaaaaaa",
"output": "aaaaaaa"
},
{
"input": "aabaabaaa",
"output": "aabaabaaa"
},
{
"input": "babaaa",
"output": "babaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "aaababbbb",
"output": "aaababbbb"
},
{
"input": "abaaaaba",
"output": "abaaaaba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "bbaaababab",
"output": "bbaaababab"
},
{
"input": "baabbbb",
"output": "baabbbb"
},
{
"input": "bb",
"output": "bb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000055
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbabbabab') == 'ABBABBABAB'
>>> apply_pipeline('bbabb') == 'BBABB'
>>> apply_pipeline('babbab') == 'BABBAB'
>>> apply_pipeline('aaababaa') == 'AAAAABAA'
>>> apply_pipeline('aaababba') == 'AAAAABBA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('ababaabab') == 'ABABAAAAB'
>>> apply_pipeline('a') == 'A'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('bbbb', 'ba')
s = s.replace('aab', 'aaa')
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bbbb",
"ba"
]
},
{
"method": "replace",
"args": [
"aab",
"aaa"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbabbabab') == 'ABBABBABAB'
assert candidate('bbabb') == 'BBABB'
assert candidate('babbab') == 'BABBAB'
assert candidate('aaababaa') == 'AAAAABAA'
assert candidate('aaababba') == 'AAAAABBA'
assert candidate('a') == 'A'
assert candidate('ababaabab') == 'ABABAAAAB'
assert candidate('a') == 'A'
# hidden tests
assert candidate('aaaa') == 'AAAA'
assert candidate('baba') == 'BABA'
assert candidate('babbabb') == 'BABBABB'
assert candidate('baa') == 'BAA'
assert candidate('bbaabbbba') == 'BBAAAAA'
assert candidate('baaab') == 'BAAAA'
assert candidate('ab') == 'AB'
assert candidate('bbbab') == 'BBBAB'
assert candidate('b') == 'B'
assert candidate('baa') == 'BAA'
assert candidate('baabbba') == 'BAAABBA'
assert candidate('abb') == 'ABB'
assert candidate('babbaa') == 'BABBAA'
assert candidate('ababbaa') == 'ABABBAA'
assert candidate('abaabaaaba') == 'ABAAAAAAAA'
assert candidate('babbaba') == 'BABBABA'
assert candidate('bba') == 'BBA'
assert candidate('aa') == 'AA'
assert candidate('aabba') == 'AAABA'
assert candidate('aaaba') == 'AAAAA'
assert candidate('bbaaaaa') == 'BBAAAAA'
assert candidate('babb') == 'BABB'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('babbaa') == 'BABBAA'
assert candidate('ababbaaaa') == 'ABABBAAAA'
assert candidate('bbaababaab') == 'BBAAAABAAA'
assert candidate('abbabaaaba') == 'ABBABAAAAA'
assert candidate('aabaaaaaba') == 'AAAAAAAAAA'
assert candidate('babbba') == 'BABBBA'
assert candidate('b') == 'B'
assert candidate('bba') == 'BBA'
assert candidate('bbabaabb') == 'BBABAAAB'
| 40
|
[
{
"input": "abbabbabab",
"output": "ABBABBABAB"
},
{
"input": "bbabb",
"output": "BBABB"
},
{
"input": "babbab",
"output": "BABBAB"
},
{
"input": "aaababaa",
"output": "AAAAABAA"
},
{
"input": "aaababba",
"output": "AAAAABBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababaabab",
"output": "ABABAAAAB"
},
{
"input": "a",
"output": "A"
}
] |
[
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "babbabb",
"output": "BABBABB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbaabbbba",
"output": "BBAAAAA"
},
{
"input": "baaab",
"output": "BAAAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "baabbba",
"output": "BAAABBA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "babbaa",
"output": "BABBAA"
},
{
"input": "ababbaa",
"output": "ABABBAA"
},
{
"input": "abaabaaaba",
"output": "ABAAAAAAAA"
},
{
"input": "babbaba",
"output": "BABBABA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabba",
"output": "AAABA"
},
{
"input": "aaaba",
"output": "AAAAA"
},
{
"input": "bbaaaaa",
"output": "BBAAAAA"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "babbaa",
"output": "BABBAA"
},
{
"input": "ababbaaaa",
"output": "ABABBAAAA"
},
{
"input": "bbaababaab",
"output": "BBAAAABAAA"
},
{
"input": "abbabaaaba",
"output": "ABBABAAAAA"
},
{
"input": "aabaaaaaba",
"output": "AAAAAAAAAA"
},
{
"input": "babbba",
"output": "BABBBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "bbabaabb",
"output": "BBABAAAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000056
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbbbba') == 'ABBBBBA'
>>> apply_pipeline('aba') == 'ABA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bbbaaabaa') == 'BBBAAABAA'
>>> apply_pipeline('aabbbaa') == 'AABBBAA'
>>> apply_pipeline('abaabbaab') == 'ABAABBAAB'
>>> apply_pipeline('aab') == 'AAB'
>>> apply_pipeline('bbbbb') == 'BBBBB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.replace('abbb', 'abbb')
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abbb",
"abbb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbbba') == 'ABBBBBA'
assert candidate('aba') == 'ABA'
assert candidate('b') == 'B'
assert candidate('bbbaaabaa') == 'BBBAAABAA'
assert candidate('aabbbaa') == 'AABBBAA'
assert candidate('abaabbaab') == 'ABAABBAAB'
assert candidate('aab') == 'AAB'
assert candidate('bbbbb') == 'BBBBB'
# hidden tests
assert candidate('aab') == 'AAB'
assert candidate('b') == 'B'
assert candidate('abaaba') == 'ABAABA'
assert candidate('aaabaaa') == 'AAABAAA'
assert candidate('baaaa') == 'BAAAA'
assert candidate('abbabbbbb') == 'ABBABBBBB'
assert candidate('babaa') == 'BABAA'
assert candidate('ba') == 'BA'
assert candidate('bb') == 'BB'
assert candidate('bbaaab') == 'BBAAAB'
assert candidate('ba') == 'BA'
assert candidate('baabaa') == 'BAABAA'
assert candidate('bbb') == 'BBB'
assert candidate('ababbbab') == 'ABABBBAB'
assert candidate('aaaabaaaa') == 'AAAABAAAA'
assert candidate('b') == 'B'
assert candidate('bb') == 'BB'
assert candidate('aaabaa') == 'AAABAA'
assert candidate('aaabbba') == 'AAABBBA'
assert candidate('b') == 'B'
assert candidate('aababbbbab') == 'AABABBBBAB'
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('bba') == 'BBA'
assert candidate('baababbb') == 'BAABABBB'
assert candidate('aaa') == 'AAA'
assert candidate('aababbb') == 'AABABBB'
assert candidate('ab') == 'AB'
assert candidate('aabbaa') == 'AABBAA'
assert candidate('aabbbabbbb') == 'AABBBABBBB'
assert candidate('baa') == 'BAA'
assert candidate('bb') == 'BB'
assert candidate('babb') == 'BABB'
| 40
|
[
{
"input": "abbbbba",
"output": "ABBBBBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbaaabaa",
"output": "BBBAAABAA"
},
{
"input": "aabbbaa",
"output": "AABBBAA"
},
{
"input": "abaabbaab",
"output": "ABAABBAAB"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbbbb",
"output": "BBBBB"
}
] |
[
{
"input": "aab",
"output": "AAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "aaabaaa",
"output": "AAABAAA"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "abbabbbbb",
"output": "ABBABBBBB"
},
{
"input": "babaa",
"output": "BABAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbaaab",
"output": "BBAAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "ababbbab",
"output": "ABABBBAB"
},
{
"input": "aaaabaaaa",
"output": "AAAABAAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aaabaa",
"output": "AAABAA"
},
{
"input": "aaabbba",
"output": "AAABBBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aababbbbab",
"output": "AABABBBBAB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "baababbb",
"output": "BAABABBB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aababbb",
"output": "AABABBB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aabbaa",
"output": "AABBAA"
},
{
"input": "aabbbabbbb",
"output": "AABBBABBBB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "babb",
"output": "BABB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000057
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aab') == 'AAB'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('aababaab') == 'AAabaAAB'
>>> apply_pipeline('ababababba') == 'AabaAabaBA'
>>> apply_pipeline('babbbab') == 'abaBaba'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aaaabbab') == 'AAAABaba'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
s = s.replace('BAB', 'aba')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAB",
"aba"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('aab') == 'AAB'
assert candidate('aa') == 'AA'
assert candidate('aababaab') == 'AAabaAAB'
assert candidate('ababababba') == 'AabaAabaBA'
assert candidate('babbbab') == 'abaBaba'
assert candidate('a') == 'A'
assert candidate('aaaabbab') == 'AAAABaba'
# hidden tests
assert candidate('aabab') == 'AAaba'
assert candidate('ba') == 'BA'
assert candidate('babaab') == 'abaAAB'
assert candidate('a') == 'A'
assert candidate('bbbabbaba') == 'BBabaabaA'
assert candidate('babababba') == 'abaAabaBA'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('bbb') == 'BBB'
assert candidate('aa') == 'AA'
assert candidate('babbb') == 'abaBB'
assert candidate('bbaabbbaa') == 'BBAABBBAA'
assert candidate('babb') == 'abaB'
assert candidate('abbba') == 'ABBBA'
assert candidate('aaaa') == 'AAAA'
assert candidate('bbba') == 'BBBA'
assert candidate('abaabbbb') == 'ABAABBBB'
assert candidate('bbababab') == 'BabaAaba'
assert candidate('babbbbbb') == 'abaBBBBB'
assert candidate('abbab') == 'ABaba'
assert candidate('bbba') == 'BBBA'
assert candidate('bbbb') == 'BBBB'
assert candidate('bbabaabbb') == 'BabaAABBB'
assert candidate('abbbab') == 'ABBaba'
assert candidate('ab') == 'AB'
assert candidate('aaaaaaba') == 'AAAAAABA'
assert candidate('bbbaabb') == 'BBBAABB'
assert candidate('abbbab') == 'ABBaba'
assert candidate('aab') == 'AAB'
assert candidate('aaabbaa') == 'AAABBAA'
assert candidate('aa') == 'AA'
assert candidate('bbaab') == 'BBAAB'
| 40
|
[
{
"input": "b",
"output": "B"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aababaab",
"output": "AAabaAAB"
},
{
"input": "ababababba",
"output": "AabaAabaBA"
},
{
"input": "babbbab",
"output": "abaBaba"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaabbab",
"output": "AAAABaba"
}
] |
[
{
"input": "aabab",
"output": "AAaba"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "babaab",
"output": "abaAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbabbaba",
"output": "BBabaabaA"
},
{
"input": "babababba",
"output": "abaAabaBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "babbb",
"output": "abaBB"
},
{
"input": "bbaabbbaa",
"output": "BBAABBBAA"
},
{
"input": "babb",
"output": "abaB"
},
{
"input": "abbba",
"output": "ABBBA"
},
{
"input": "aaaa",
"output": "AAAA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "bbababab",
"output": "BabaAaba"
},
{
"input": "babbbbbb",
"output": "abaBBBBB"
},
{
"input": "abbab",
"output": "ABaba"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "bbabaabbb",
"output": "BabaAABBB"
},
{
"input": "abbbab",
"output": "ABBaba"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaaaaaba",
"output": "AAAAAABA"
},
{
"input": "bbbaabb",
"output": "BBBAABB"
},
{
"input": "abbbab",
"output": "ABBaba"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbaab",
"output": "BBAAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000058
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babaa') == 'babaa'
>>> apply_pipeline('bba') == 'bba'
>>> apply_pipeline('aabba') == 'aabba'
>>> apply_pipeline('bbbbbb') == 'aaaaaa'
>>> apply_pipeline('abaabbaa') == 'abaabbaa'
>>> apply_pipeline('bbabbbab') == 'bbaaaaab'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('baabbbabaa') == 'baaaaaabaa'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbb', 'aaa')
s = s.lower()
return s
|
[
{
"method": "replace",
"args": [
"bbb",
"aaa"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'babaa'
assert candidate('bba') == 'bba'
assert candidate('aabba') == 'aabba'
assert candidate('bbbbbb') == 'aaaaaa'
assert candidate('abaabbaa') == 'abaabbaa'
assert candidate('bbabbbab') == 'bbaaaaab'
assert candidate('b') == 'b'
assert candidate('baabbbabaa') == 'baaaaaabaa'
# hidden tests
assert candidate('aba') == 'aba'
assert candidate('aaabbba') == 'aaaaaaa'
assert candidate('baaabba') == 'baaabba'
assert candidate('a') == 'a'
assert candidate('aabbaa') == 'aabbaa'
assert candidate('baaaaaabb') == 'baaaaaabb'
assert candidate('bbababaab') == 'bbababaab'
assert candidate('bb') == 'bb'
assert candidate('aba') == 'aba'
assert candidate('bab') == 'bab'
assert candidate('b') == 'b'
assert candidate('aaababbbb') == 'aaabaaaab'
assert candidate('bbbaa') == 'aaaaa'
assert candidate('abbbb') == 'aaaab'
assert candidate('aabb') == 'aabb'
assert candidate('baabbb') == 'baaaaa'
assert candidate('baaaba') == 'baaaba'
assert candidate('aaaaaab') == 'aaaaaab'
assert candidate('b') == 'b'
assert candidate('bbaaaaab') == 'bbaaaaab'
assert candidate('bb') == 'bb'
assert candidate('abba') == 'abba'
assert candidate('abbababbaa') == 'abbababbaa'
assert candidate('babbaabaab') == 'babbaabaab'
assert candidate('abbbbbaa') == 'aaaabbaa'
assert candidate('aaaaaa') == 'aaaaaa'
assert candidate('aba') == 'aba'
assert candidate('b') == 'b'
assert candidate('bbbbbbbab') == 'aaaaaabab'
assert candidate('babbb') == 'baaaa'
assert candidate('bbbaaabaab') == 'aaaaaabaab'
assert candidate('bbabbb') == 'bbaaaa'
| 40
|
[
{
"input": "babaa",
"output": "babaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "bbbbbb",
"output": "aaaaaa"
},
{
"input": "abaabbaa",
"output": "abaabbaa"
},
{
"input": "bbabbbab",
"output": "bbaaaaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "baabbbabaa",
"output": "baaaaaabaa"
}
] |
[
{
"input": "aba",
"output": "aba"
},
{
"input": "aaabbba",
"output": "aaaaaaa"
},
{
"input": "baaabba",
"output": "baaabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabbaa",
"output": "aabbaa"
},
{
"input": "baaaaaabb",
"output": "baaaaaabb"
},
{
"input": "bbababaab",
"output": "bbababaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaababbbb",
"output": "aaabaaaab"
},
{
"input": "bbbaa",
"output": "aaaaa"
},
{
"input": "abbbb",
"output": "aaaab"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "baabbb",
"output": "baaaaa"
},
{
"input": "baaaba",
"output": "baaaba"
},
{
"input": "aaaaaab",
"output": "aaaaaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbaaaaab",
"output": "bbaaaaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "abbababbaa",
"output": "abbababbaa"
},
{
"input": "babbaabaab",
"output": "babbaabaab"
},
{
"input": "abbbbbaa",
"output": "aaaabbaa"
},
{
"input": "aaaaaa",
"output": "aaaaaa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbbbbbbab",
"output": "aaaaaabab"
},
{
"input": "babbb",
"output": "baaaa"
},
{
"input": "bbbaaabaab",
"output": "aaaaaabaab"
},
{
"input": "bbabbb",
"output": "bbaaaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000059
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabba') == 'AABBA'
>>> apply_pipeline('ababbbbaba') == 'ABABBBBABA'
>>> apply_pipeline('aabbab') == 'AABBAB'
>>> apply_pipeline('abbbbabb') == 'ABBBBABB'
>>> apply_pipeline('aaab') == 'AAAB'
>>> apply_pipeline('aba') == 'ABA'
>>> apply_pipeline('bbaabbb') == 'BBAABBB'
>>> apply_pipeline('abbbba') == 'ABBBBA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabba') == 'AABBA'
assert candidate('ababbbbaba') == 'ABABBBBABA'
assert candidate('aabbab') == 'AABBAB'
assert candidate('abbbbabb') == 'ABBBBABB'
assert candidate('aaab') == 'AAAB'
assert candidate('aba') == 'ABA'
assert candidate('bbaabbb') == 'BBAABBB'
assert candidate('abbbba') == 'ABBBBA'
# hidden tests
assert candidate('abbbbbabb') == 'ABBBBBABB'
assert candidate('a') == 'A'
assert candidate('baabaaabb') == 'BAABAAABB'
assert candidate('b') == 'B'
assert candidate('b') == 'B'
assert candidate('bb') == 'BB'
assert candidate('babbbababb') == 'BABBBABABB'
assert candidate('baabbbbaab') == 'BAABBBBAAB'
assert candidate('a') == 'A'
assert candidate('baaabbaaab') == 'BAAABBAAAB'
assert candidate('b') == 'B'
assert candidate('babbabba') == 'BABBABBA'
assert candidate('aababbb') == 'AABABBB'
assert candidate('babb') == 'BABB'
assert candidate('bbba') == 'BBBA'
assert candidate('abaaabaa') == 'ABAAABAA'
assert candidate('baaa') == 'BAAA'
assert candidate('ba') == 'BA'
assert candidate('b') == 'B'
assert candidate('abbab') == 'ABBAB'
assert candidate('abbbbab') == 'ABBBBAB'
assert candidate('aaaababbb') == 'AAAABABBB'
assert candidate('abaababab') == 'ABAABABAB'
assert candidate('baabbaaaaa') == 'BAABBAAAAA'
assert candidate('aba') == 'ABA'
assert candidate('abaaba') == 'ABAABA'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('baabbbb') == 'BAABBBB'
assert candidate('aa') == 'AA'
assert candidate('baabbaaba') == 'BAABBAABA'
assert candidate('a') == 'A'
assert candidate('aabbbabba') == 'AABBBABBA'
| 40
|
[
{
"input": "aabba",
"output": "AABBA"
},
{
"input": "ababbbbaba",
"output": "ABABBBBABA"
},
{
"input": "aabbab",
"output": "AABBAB"
},
{
"input": "abbbbabb",
"output": "ABBBBABB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "bbaabbb",
"output": "BBAABBB"
},
{
"input": "abbbba",
"output": "ABBBBA"
}
] |
[
{
"input": "abbbbbabb",
"output": "ABBBBBABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "baabaaabb",
"output": "BAABAAABB"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "babbbababb",
"output": "BABBBABABB"
},
{
"input": "baabbbbaab",
"output": "BAABBBBAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "baaabbaaab",
"output": "BAAABBAAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "babbabba",
"output": "BABBABBA"
},
{
"input": "aababbb",
"output": "AABABBB"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "abaaabaa",
"output": "ABAAABAA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "b",
"output": "B"
},
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "abbbbab",
"output": "ABBBBAB"
},
{
"input": "aaaababbb",
"output": "AAAABABBB"
},
{
"input": "abaababab",
"output": "ABAABABAB"
},
{
"input": "baabbaaaaa",
"output": "BAABBAAAAA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "baabbbb",
"output": "BAABBBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "baabbaaba",
"output": "BAABBAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aabbbabba",
"output": "AABBBABBA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000060
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('ababbab') == 'ababbab'
>>> apply_pipeline('baaaa') == 'baaaa'
>>> apply_pipeline('aabab') == 'aabab'
>>> apply_pipeline('abba') == 'abba'
>>> apply_pipeline('baabababaa') == 'bbaaababaa'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('abbb') == 'abbb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('baab', 'bbaa')
return s
|
[
{
"method": "replace",
"args": [
"baab",
"bbaa"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('a') == 'a'
assert candidate('ababbab') == 'ababbab'
assert candidate('baaaa') == 'baaaa'
assert candidate('aabab') == 'aabab'
assert candidate('abba') == 'abba'
assert candidate('baabababaa') == 'bbaaababaa'
assert candidate('abbb') == 'abbb'
assert candidate('abbb') == 'abbb'
# hidden tests
assert candidate('babba') == 'babba'
assert candidate('ab') == 'ab'
assert candidate('abbabab') == 'abbabab'
assert candidate('bbbbaaaabb') == 'bbbbaaaabb'
assert candidate('bbbbbbb') == 'bbbbbbb'
assert candidate('abaababb') == 'abbaaabb'
assert candidate('aaabb') == 'aaabb'
assert candidate('bbabbabaa') == 'bbabbabaa'
assert candidate('abbabbbbb') == 'abbabbbbb'
assert candidate('aabababb') == 'aabababb'
assert candidate('abaaababaa') == 'abaaababaa'
assert candidate('baaababaa') == 'baaababaa'
assert candidate('aaaa') == 'aaaa'
assert candidate('abbb') == 'abbb'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('baabbaabbb') == 'bbaabbaabb'
assert candidate('abaaba') == 'abbaaa'
assert candidate('aabbbbbb') == 'aabbbbbb'
assert candidate('aaaaba') == 'aaaaba'
assert candidate('bbaaba') == 'bbbaaa'
assert candidate('bbabbabb') == 'bbabbabb'
assert candidate('bbaaaaaaa') == 'bbaaaaaaa'
assert candidate('abaa') == 'abaa'
assert candidate('bbbaabbaba') == 'bbbbaababa'
assert candidate('ba') == 'ba'
assert candidate('bbaab') == 'bbbaa'
assert candidate('bbbabaaaaa') == 'bbbabaaaaa'
assert candidate('aabaaabb') == 'aabaaabb'
assert candidate('aaaaaa') == 'aaaaaa'
assert candidate('bb') == 'bb'
assert candidate('bbabb') == 'bbabb'
| 40
|
[
{
"input": "a",
"output": "a"
},
{
"input": "ababbab",
"output": "ababbab"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "baabababaa",
"output": "bbaaababaa"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "abbb",
"output": "abbb"
}
] |
[
{
"input": "babba",
"output": "babba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "abbabab",
"output": "abbabab"
},
{
"input": "bbbbaaaabb",
"output": "bbbbaaaabb"
},
{
"input": "bbbbbbb",
"output": "bbbbbbb"
},
{
"input": "abaababb",
"output": "abbaaabb"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "bbabbabaa",
"output": "bbabbabaa"
},
{
"input": "abbabbbbb",
"output": "abbabbbbb"
},
{
"input": "aabababb",
"output": "aabababb"
},
{
"input": "abaaababaa",
"output": "abaaababaa"
},
{
"input": "baaababaa",
"output": "baaababaa"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "baabbaabbb",
"output": "bbaabbaabb"
},
{
"input": "abaaba",
"output": "abbaaa"
},
{
"input": "aabbbbbb",
"output": "aabbbbbb"
},
{
"input": "aaaaba",
"output": "aaaaba"
},
{
"input": "bbaaba",
"output": "bbbaaa"
},
{
"input": "bbabbabb",
"output": "bbabbabb"
},
{
"input": "bbaaaaaaa",
"output": "bbaaaaaaa"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "bbbaabbaba",
"output": "bbbbaababa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbaab",
"output": "bbbaa"
},
{
"input": "bbbabaaaaa",
"output": "bbbabaaaaa"
},
{
"input": "aabaaabb",
"output": "aabaaabb"
},
{
"input": "aaaaaa",
"output": "aaaaaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbabb",
"output": "bbabb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000061
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('ababb') == 'ABABB'
>>> apply_pipeline('ababaabbb') == 'ABABAABBB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aaabaab') == 'AAABAAB'
>>> apply_pipeline('aababb') == 'AABABB'
>>> apply_pipeline('aaaaa') == 'AAAAA'
>>> apply_pipeline('aabbb') == 'AABBB'
>>> apply_pipeline('bba') == 'BBA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ababb') == 'ABABB'
assert candidate('ababaabbb') == 'ABABAABBB'
assert candidate('b') == 'B'
assert candidate('aaabaab') == 'AAABAAB'
assert candidate('aababb') == 'AABABB'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('aabbb') == 'AABBB'
assert candidate('bba') == 'BBA'
# hidden tests
assert candidate('bbabaaa') == 'BBABAAA'
assert candidate('bab') == 'BAB'
assert candidate('abbaaaaa') == 'ABBAAAAA'
assert candidate('aabbbbabba') == 'AABBBBABBA'
assert candidate('babbbaba') == 'BABBBABA'
assert candidate('abba') == 'ABBA'
assert candidate('b') == 'B'
assert candidate('bbaababa') == 'BBAABABA'
assert candidate('baaba') == 'BAABA'
assert candidate('babbaaaaa') == 'BABBAAAAA'
assert candidate('b') == 'B'
assert candidate('bbaa') == 'BBAA'
assert candidate('a') == 'A'
assert candidate('bbaa') == 'BBAA'
assert candidate('bbb') == 'BBB'
assert candidate('b') == 'B'
assert candidate('baaa') == 'BAAA'
assert candidate('baba') == 'BABA'
assert candidate('aaaabaa') == 'AAAABAA'
assert candidate('abbbbaba') == 'ABBBBABA'
assert candidate('aabbb') == 'AABBB'
assert candidate('aaabb') == 'AAABB'
assert candidate('ab') == 'AB'
assert candidate('abaa') == 'ABAA'
assert candidate('baba') == 'BABA'
assert candidate('babab') == 'BABAB'
assert candidate('bbbabbaa') == 'BBBABBAA'
assert candidate('abbaababa') == 'ABBAABABA'
assert candidate('bb') == 'BB'
assert candidate('baaa') == 'BAAA'
assert candidate('bababaab') == 'BABABAAB'
assert candidate('bbbbbabaab') == 'BBBBBABAAB'
| 40
|
[
{
"input": "ababb",
"output": "ABABB"
},
{
"input": "ababaabbb",
"output": "ABABAABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaabaab",
"output": "AAABAAB"
},
{
"input": "aababb",
"output": "AABABB"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "bba",
"output": "BBA"
}
] |
[
{
"input": "bbabaaa",
"output": "BBABAAA"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbaaaaa",
"output": "ABBAAAAA"
},
{
"input": "aabbbbabba",
"output": "AABBBBABBA"
},
{
"input": "babbbaba",
"output": "BABBBABA"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaababa",
"output": "BBAABABA"
},
{
"input": "baaba",
"output": "BAABA"
},
{
"input": "babbaaaaa",
"output": "BABBAAAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "aaaabaa",
"output": "AAAABAA"
},
{
"input": "abbbbaba",
"output": "ABBBBABA"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "aaabb",
"output": "AAABB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "babab",
"output": "BABAB"
},
{
"input": "bbbabbaa",
"output": "BBBABBAA"
},
{
"input": "abbaababa",
"output": "ABBAABABA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "bababaab",
"output": "BABABAAB"
},
{
"input": "bbbbbabaab",
"output": "BBBBBABAAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000062
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('baa') == 'BAA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('abaaa') == 'ABAAA'
>>> apply_pipeline('bbbaba') == 'BBBABA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('babbba') == 'BABBBA'
>>> apply_pipeline('aaaabbbbaa') == 'AAAABBBBAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baa') == 'BAA'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('abaaa') == 'ABAAA'
assert candidate('bbbaba') == 'BBBABA'
assert candidate('b') == 'B'
assert candidate('babbba') == 'BABBBA'
assert candidate('aaaabbbbaa') == 'AAAABBBBAA'
# hidden tests
assert candidate('aab') == 'AAB'
assert candidate('bbbababab') == 'BBBABABAB'
assert candidate('bbb') == 'BBB'
assert candidate('bbbaaaaba') == 'BBBAAAABA'
assert candidate('baaab') == 'BAAAB'
assert candidate('babb') == 'BABB'
assert candidate('a') == 'A'
assert candidate('aa') == 'AA'
assert candidate('bba') == 'BBA'
assert candidate('aabab') == 'AABAB'
assert candidate('ab') == 'AB'
assert candidate('aaaabbab') == 'AAAABBAB'
assert candidate('babaaaba') == 'BABAAABA'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('ababaaaba') == 'ABABAAABA'
assert candidate('abbbabba') == 'ABBBABBA'
assert candidate('babbabbaaa') == 'BABBABBAAA'
assert candidate('abbb') == 'ABBB'
assert candidate('bbaab') == 'BBAAB'
assert candidate('bbabba') == 'BBABBA'
assert candidate('abbb') == 'ABBB'
assert candidate('baaaaabbaa') == 'BAAAAABBAA'
assert candidate('baabaaa') == 'BAABAAA'
assert candidate('bbaaabb') == 'BBAAABB'
assert candidate('aaaaabb') == 'AAAAABB'
assert candidate('baaba') == 'BAABA'
assert candidate('abbaabb') == 'ABBAABB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('babaabaaa') == 'BABAABAAA'
assert candidate('baabbabb') == 'BAABBABB'
assert candidate('baaabaaaba') == 'BAAABAAABA'
assert candidate('baabaaabbb') == 'BAABAAABBB'
| 40
|
[
{
"input": "baa",
"output": "BAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "bbbaba",
"output": "BBBABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "babbba",
"output": "BABBBA"
},
{
"input": "aaaabbbbaa",
"output": "AAAABBBBAA"
}
] |
[
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbbababab",
"output": "BBBABABAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "bbbaaaaba",
"output": "BBBAAAABA"
},
{
"input": "baaab",
"output": "BAAAB"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "aabab",
"output": "AABAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aaaabbab",
"output": "AAAABBAB"
},
{
"input": "babaaaba",
"output": "BABAAABA"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "ababaaaba",
"output": "ABABAAABA"
},
{
"input": "abbbabba",
"output": "ABBBABBA"
},
{
"input": "babbabbaaa",
"output": "BABBABBAAA"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "bbaab",
"output": "BBAAB"
},
{
"input": "bbabba",
"output": "BBABBA"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "baaaaabbaa",
"output": "BAAAAABBAA"
},
{
"input": "baabaaa",
"output": "BAABAAA"
},
{
"input": "bbaaabb",
"output": "BBAAABB"
},
{
"input": "aaaaabb",
"output": "AAAAABB"
},
{
"input": "baaba",
"output": "BAABA"
},
{
"input": "abbaabb",
"output": "ABBAABB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "babaabaaa",
"output": "BABAABAAA"
},
{
"input": "baabbabb",
"output": "BAABBABB"
},
{
"input": "baaabaaaba",
"output": "BAAABAAABA"
},
{
"input": "baabaaabbb",
"output": "BAABAAABBB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000063
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babaa') == 'babaa'
>>> apply_pipeline('abbba') == 'abbba'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('baababb') == 'baababb'
>>> apply_pipeline('aaaaaaaabb') == 'aaaaaaaabb'
>>> apply_pipeline('abbaa') == 'abbaa'
>>> apply_pipeline('baaa') == 'baaa'
>>> apply_pipeline('ba') == 'ba'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbbb', 'aaaba')
s = s.lower()
return s
|
[
{
"method": "replace",
"args": [
"bbbb",
"aaaba"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'babaa'
assert candidate('abbba') == 'abbba'
assert candidate('a') == 'a'
assert candidate('baababb') == 'baababb'
assert candidate('aaaaaaaabb') == 'aaaaaaaabb'
assert candidate('abbaa') == 'abbaa'
assert candidate('baaa') == 'baaa'
assert candidate('ba') == 'ba'
# hidden tests
assert candidate('abb') == 'abb'
assert candidate('baab') == 'baab'
assert candidate('bba') == 'bba'
assert candidate('aabb') == 'aabb'
assert candidate('aa') == 'aa'
assert candidate('bbbbababbb') == 'aaabaababbb'
assert candidate('aabbba') == 'aabbba'
assert candidate('ab') == 'ab'
assert candidate('bbaa') == 'bbaa'
assert candidate('babbbbaaa') == 'baaaabaaaa'
assert candidate('baaaaa') == 'baaaaa'
assert candidate('abbaaaaba') == 'abbaaaaba'
assert candidate('baaaabaaa') == 'baaaabaaa'
assert candidate('abbbbaaa') == 'aaaabaaaa'
assert candidate('aaababab') == 'aaababab'
assert candidate('ababb') == 'ababb'
assert candidate('bbaa') == 'bbaa'
assert candidate('bbbaaabaaa') == 'bbbaaabaaa'
assert candidate('bbaabaaaaa') == 'bbaabaaaaa'
assert candidate('abaaaba') == 'abaaaba'
assert candidate('aaa') == 'aaa'
assert candidate('ababb') == 'ababb'
assert candidate('abaa') == 'abaa'
assert candidate('abbaabbbbb') == 'abbaaaaabab'
assert candidate('a') == 'a'
assert candidate('abbb') == 'abbb'
assert candidate('aabab') == 'aabab'
assert candidate('bbaabbb') == 'bbaabbb'
assert candidate('aababbbab') == 'aababbbab'
assert candidate('aab') == 'aab'
assert candidate('ab') == 'ab'
assert candidate('b') == 'b'
| 40
|
[
{
"input": "babaa",
"output": "babaa"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "a",
"output": "a"
},
{
"input": "baababb",
"output": "baababb"
},
{
"input": "aaaaaaaabb",
"output": "aaaaaaaabb"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "ba",
"output": "ba"
}
] |
[
{
"input": "abb",
"output": "abb"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbbababbb",
"output": "aaabaababbb"
},
{
"input": "aabbba",
"output": "aabbba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "babbbbaaa",
"output": "baaaabaaaa"
},
{
"input": "baaaaa",
"output": "baaaaa"
},
{
"input": "abbaaaaba",
"output": "abbaaaaba"
},
{
"input": "baaaabaaa",
"output": "baaaabaaa"
},
{
"input": "abbbbaaa",
"output": "aaaabaaaa"
},
{
"input": "aaababab",
"output": "aaababab"
},
{
"input": "ababb",
"output": "ababb"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "bbbaaabaaa",
"output": "bbbaaabaaa"
},
{
"input": "bbaabaaaaa",
"output": "bbaabaaaaa"
},
{
"input": "abaaaba",
"output": "abaaaba"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "ababb",
"output": "ababb"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "abbaabbbbb",
"output": "abbaaaaabab"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "bbaabbb",
"output": "bbaabbb"
},
{
"input": "aababbbab",
"output": "aababbbab"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "b",
"output": "b"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000064
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaabbaa') == 'AAABBAA'
>>> apply_pipeline('bbaba') == 'BBABA'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bababaaa') == 'BABABAAA'
>>> apply_pipeline('baaababbaa') == 'BAAABABBAA'
>>> apply_pipeline('baaabbb') == 'BAAABBB'
>>> apply_pipeline('bbaabb') == 'BBAABB'
>>> apply_pipeline('ba') == 'BA'
"""
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('aaabbaa') == 'AAABBAA'
assert candidate('bbaba') == 'BBABA'
assert candidate('b') == 'B'
assert candidate('bababaaa') == 'BABABAAA'
assert candidate('baaababbaa') == 'BAAABABBAA'
assert candidate('baaabbb') == 'BAAABBB'
assert candidate('bbaabb') == 'BBAABB'
assert candidate('ba') == 'BA'
# hidden tests
assert candidate('baa') == 'BAA'
assert candidate('aabb') == 'AABB'
assert candidate('abab') == 'ABAB'
assert candidate('abbaba') == 'ABBABA'
assert candidate('aaab') == 'AAAB'
assert candidate('babbbaab') == 'BABBBAAB'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('b') == 'B'
assert candidate('bb') == 'BB'
assert candidate('ab') == 'AB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('aa') == 'AA'
assert candidate('aaababbab') == 'AAABABBAB'
assert candidate('aaaaaab') == 'AAAAAAB'
assert candidate('bbbbaab') == 'BBBBAAB'
assert candidate('bbbbaa') == 'BBBBAA'
assert candidate('abbabbb') == 'ABBABBB'
assert candidate('baaabbaab') == 'BAAABBAAB'
assert candidate('aaaabba') == 'AAAABBA'
assert candidate('aaaaabb') == 'AAAAABB'
assert candidate('ababab') == 'ABABAB'
assert candidate('aabaaaaa') == 'AABAAAAA'
assert candidate('abbabbbaab') == 'ABBABBBAAB'
assert candidate('aaa') == 'AAA'
assert candidate('aaba') == 'AABA'
assert candidate('ab') == 'AB'
assert candidate('abaa') == 'ABAA'
assert candidate('baa') == 'BAA'
assert candidate('aaabbbaba') == 'AAABBBABA'
assert candidate('bbbbaa') == 'BBBBAA'
assert candidate('b') == 'B'
assert candidate('aaaa') == 'AAAA'
| 40
|
[
{
"input": "aaabbaa",
"output": "AAABBAA"
},
{
"input": "bbaba",
"output": "BBABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababaaa",
"output": "BABABAAA"
},
{
"input": "baaababbaa",
"output": "BAAABABBAA"
},
{
"input": "baaabbb",
"output": "BAAABBB"
},
{
"input": "bbaabb",
"output": "BBAABB"
},
{
"input": "ba",
"output": "BA"
}
] |
[
{
"input": "baa",
"output": "BAA"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "abbaba",
"output": "ABBABA"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "babbbaab",
"output": "BABBBAAB"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aaababbab",
"output": "AAABABBAB"
},
{
"input": "aaaaaab",
"output": "AAAAAAB"
},
{
"input": "bbbbaab",
"output": "BBBBAAB"
},
{
"input": "bbbbaa",
"output": "BBBBAA"
},
{
"input": "abbabbb",
"output": "ABBABBB"
},
{
"input": "baaabbaab",
"output": "BAAABBAAB"
},
{
"input": "aaaabba",
"output": "AAAABBA"
},
{
"input": "aaaaabb",
"output": "AAAAABB"
},
{
"input": "ababab",
"output": "ABABAB"
},
{
"input": "aabaaaaa",
"output": "AABAAAAA"
},
{
"input": "abbabbbaab",
"output": "ABBABBBAAB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "aaabbbaba",
"output": "AAABBBABA"
},
{
"input": "bbbbaa",
"output": "BBBBAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaa",
"output": "AAAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000065
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babbab') == 'babbab'
>>> apply_pipeline('bababbbbb') == 'bababbbbb'
>>> apply_pipeline('bbbbabab') == 'bbbbabab'
>>> apply_pipeline('aaababbab') == 'aaababbab'
>>> apply_pipeline('baaabaab') == 'baaabaab'
>>> apply_pipeline('bab') == 'bab'
>>> apply_pipeline('baababbaba') == 'baababbaba'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbabb', 'baabb')
return s
|
[
{
"method": "replace",
"args": [
"bbabb",
"baabb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'b'
assert candidate('babbab') == 'babbab'
assert candidate('bababbbbb') == 'bababbbbb'
assert candidate('bbbbabab') == 'bbbbabab'
assert candidate('aaababbab') == 'aaababbab'
assert candidate('baaabaab') == 'baaabaab'
assert candidate('bab') == 'bab'
assert candidate('baababbaba') == 'baababbaba'
# hidden tests
assert candidate('b') == 'b'
assert candidate('baaa') == 'baaa'
assert candidate('bba') == 'bba'
assert candidate('baabbb') == 'baabbb'
assert candidate('abaaabbbb') == 'abaaabbbb'
assert candidate('bbabaaba') == 'bbabaaba'
assert candidate('bbaabbab') == 'bbaabbab'
assert candidate('bba') == 'bba'
assert candidate('baabb') == 'baabb'
assert candidate('bbbbbbb') == 'bbbbbbb'
assert candidate('bbbaabaaa') == 'bbbaabaaa'
assert candidate('ababbabbaa') == 'ababaabbaa'
assert candidate('baaaa') == 'baaaa'
assert candidate('bbbab') == 'bbbab'
assert candidate('baabbb') == 'baabbb'
assert candidate('aaa') == 'aaa'
assert candidate('abbbabaa') == 'abbbabaa'
assert candidate('aaabbaa') == 'aaabbaa'
assert candidate('a') == 'a'
assert candidate('abababbb') == 'abababbb'
assert candidate('baaaaa') == 'baaaaa'
assert candidate('abab') == 'abab'
assert candidate('abbabbbbb') == 'abaabbbbb'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('aba') == 'aba'
assert candidate('ab') == 'ab'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('bbabaaaaa') == 'bbabaaaaa'
assert candidate('baa') == 'baa'
assert candidate('aaab') == 'aaab'
assert candidate('bbabbba') == 'baabbba'
assert candidate('bababba') == 'bababba'
| 40
|
[
{
"input": "b",
"output": "b"
},
{
"input": "babbab",
"output": "babbab"
},
{
"input": "bababbbbb",
"output": "bababbbbb"
},
{
"input": "bbbbabab",
"output": "bbbbabab"
},
{
"input": "aaababbab",
"output": "aaababbab"
},
{
"input": "baaabaab",
"output": "baaabaab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "baababbaba",
"output": "baababbaba"
}
] |
[
{
"input": "b",
"output": "b"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "abaaabbbb",
"output": "abaaabbbb"
},
{
"input": "bbabaaba",
"output": "bbabaaba"
},
{
"input": "bbaabbab",
"output": "bbaabbab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "baabb",
"output": "baabb"
},
{
"input": "bbbbbbb",
"output": "bbbbbbb"
},
{
"input": "bbbaabaaa",
"output": "bbbaabaaa"
},
{
"input": "ababbabbaa",
"output": "ababaabbaa"
},
{
"input": "baaaa",
"output": "baaaa"
},
{
"input": "bbbab",
"output": "bbbab"
},
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "abbbabaa",
"output": "abbbabaa"
},
{
"input": "aaabbaa",
"output": "aaabbaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "abababbb",
"output": "abababbb"
},
{
"input": "baaaaa",
"output": "baaaaa"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "abbabbbbb",
"output": "abaabbbbb"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "bbabaaaaa",
"output": "bbabaaaaa"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "bbabbba",
"output": "baabbba"
},
{
"input": "bababba",
"output": "bababba"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000066
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbbbab') == 'BBBBAB'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('baab') == 'BAAB'
>>> apply_pipeline('baa') == 'BAA'
>>> apply_pipeline('aaba') == 'AABA'
>>> apply_pipeline('abb') == 'ABB'
>>> apply_pipeline('aaabbaa') == 'AAABBAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('bbbbab') == 'BBBBAB'
assert candidate('aaa') == 'AAA'
assert candidate('baab') == 'BAAB'
assert candidate('baa') == 'BAA'
assert candidate('aaba') == 'AABA'
assert candidate('abb') == 'ABB'
assert candidate('aaabbaa') == 'AAABBAA'
# hidden tests
assert candidate('bba') == 'BBA'
assert candidate('aba') == 'ABA'
assert candidate('abaaa') == 'ABAAA'
assert candidate('ababbbaab') == 'ABABBBAAB'
assert candidate('baaaabbb') == 'BAAAABBB'
assert candidate('a') == 'A'
assert candidate('aaababbba') == 'AAABABBBA'
assert candidate('abab') == 'ABAB'
assert candidate('baababa') == 'BAABABA'
assert candidate('aa') == 'AA'
assert candidate('a') == 'A'
assert candidate('aaaaaabbaa') == 'AAAAAABBAA'
assert candidate('aabbbbaaaa') == 'AABBBBAAAA'
assert candidate('aaaaabbaab') == 'AAAAABBAAB'
assert candidate('abb') == 'ABB'
assert candidate('ababaaaa') == 'ABABAAAA'
assert candidate('abbabaaaaa') == 'ABBABAAAAA'
assert candidate('a') == 'A'
assert candidate('bbbab') == 'BBBAB'
assert candidate('bb') == 'BB'
assert candidate('babbbab') == 'BABBBAB'
assert candidate('aaabaaba') == 'AAABAABA'
assert candidate('baaa') == 'BAAA'
assert candidate('baabaa') == 'BAABAA'
assert candidate('bbaabbb') == 'BBAABBB'
assert candidate('bbaaaabaab') == 'BBAAAABAAB'
assert candidate('ba') == 'BA'
assert candidate('b') == 'B'
assert candidate('ba') == 'BA'
assert candidate('baaaabaab') == 'BAAAABAAB'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('babaabab') == 'BABAABAB'
| 40
|
[
{
"input": "b",
"output": "B"
},
{
"input": "bbbbab",
"output": "BBBBAB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "aaabbaa",
"output": "AAABBAA"
}
] |
[
{
"input": "bba",
"output": "BBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "abaaa",
"output": "ABAAA"
},
{
"input": "ababbbaab",
"output": "ABABBBAAB"
},
{
"input": "baaaabbb",
"output": "BAAAABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaababbba",
"output": "AAABABBBA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "baababa",
"output": "BAABABA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaaaabbaa",
"output": "AAAAAABBAA"
},
{
"input": "aabbbbaaaa",
"output": "AABBBBAAAA"
},
{
"input": "aaaaabbaab",
"output": "AAAAABBAAB"
},
{
"input": "abb",
"output": "ABB"
},
{
"input": "ababaaaa",
"output": "ABABAAAA"
},
{
"input": "abbabaaaaa",
"output": "ABBABAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "babbbab",
"output": "BABBBAB"
},
{
"input": "aaabaaba",
"output": "AAABAABA"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "baabaa",
"output": "BAABAA"
},
{
"input": "bbaabbb",
"output": "BBAABBB"
},
{
"input": "bbaaaabaab",
"output": "BBAAAABAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baaaabaab",
"output": "BAAAABAAB"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "babaabab",
"output": "BABAABAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000067
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabbaab') == 'aabbaab'
>>> apply_pipeline('bbbbaaaba') == 'bbbbaaaba'
>>> apply_pipeline('baaaabb') == 'baaaabb'
>>> apply_pipeline('aba') == 'aba'
>>> apply_pipeline('bbbb') == 'bbbb'
>>> apply_pipeline('bbbbba') == 'bbbbba'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('babbaa') == 'babbaa'
"""
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('aabbaab') == 'aabbaab'
assert candidate('bbbbaaaba') == 'bbbbaaaba'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('aba') == 'aba'
assert candidate('bbbb') == 'bbbb'
assert candidate('bbbbba') == 'bbbbba'
assert candidate('a') == 'a'
assert candidate('babbaa') == 'babbaa'
# hidden tests
assert candidate('a') == 'a'
assert candidate('ba') == 'ba'
assert candidate('aabbbbaa') == 'aabbbbaa'
assert candidate('b') == 'b'
assert candidate('bbabaabbaa') == 'bbabaabbaa'
assert candidate('babb') == 'babb'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('bbbaaba') == 'bbbaaba'
assert candidate('ba') == 'ba'
assert candidate('baabaabaa') == 'baabaabaa'
assert candidate('bbbba') == 'bbbba'
assert candidate('aa') == 'aa'
assert candidate('bbbabbabaa') == 'bbbabbabaa'
assert candidate('bbbbaaba') == 'bbbbaaba'
assert candidate('baa') == 'baa'
assert candidate('aaaaaa') == 'aaaaaa'
assert candidate('babbbaa') == 'babbbaa'
assert candidate('bbaabbabb') == 'bbaabbabb'
assert candidate('aaaaaba') == 'aaaaaba'
assert candidate('abaababbaa') == 'abaababbaa'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('babbb') == 'babbb'
assert candidate('bbabbabbb') == 'bbabbabbb'
assert candidate('bbbabb') == 'bbbabb'
assert candidate('bbaaabb') == 'bbaaabb'
assert candidate('bbaaabba') == 'bbaaabba'
assert candidate('aab') == 'aab'
assert candidate('baa') == 'baa'
assert candidate('abbb') == 'abbb'
assert candidate('bba') == 'bba'
assert candidate('aabb') == 'aabb'
| 40
|
[
{
"input": "aabbaab",
"output": "aabbaab"
},
{
"input": "bbbbaaaba",
"output": "bbbbaaaba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "bbbbba",
"output": "bbbbba"
},
{
"input": "a",
"output": "a"
},
{
"input": "babbaa",
"output": "babbaa"
}
] |
[
{
"input": "a",
"output": "a"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aabbbbaa",
"output": "aabbbbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbabaabbaa",
"output": "bbabaabbaa"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "bbbaaba",
"output": "bbbaaba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "baabaabaa",
"output": "baabaabaa"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbabbabaa",
"output": "bbbabbabaa"
},
{
"input": "bbbbaaba",
"output": "bbbbaaba"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "aaaaaa",
"output": "aaaaaa"
},
{
"input": "babbbaa",
"output": "babbbaa"
},
{
"input": "bbaabbabb",
"output": "bbaabbabb"
},
{
"input": "aaaaaba",
"output": "aaaaaba"
},
{
"input": "abaababbaa",
"output": "abaababbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "babbb",
"output": "babbb"
},
{
"input": "bbabbabbb",
"output": "bbabbabbb"
},
{
"input": "bbbabb",
"output": "bbbabb"
},
{
"input": "bbaaabb",
"output": "bbaaabb"
},
{
"input": "bbaaabba",
"output": "bbaaabba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabb",
"output": "aabb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000068
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaaa') == 'bbaabbbaab'
>>> apply_pipeline('aaabaaaab') == 'bbaababbbaabbbaabb'
>>> apply_pipeline('babb') == 'babb'
>>> apply_pipeline('babbabb') == 'babb'
>>> apply_pipeline('abab') == 'abab'
>>> apply_pipeline('aabbbaa') == 'bbaabbbbbbaab'
>>> apply_pipeline('bab') == 'bab'
>>> apply_pipeline('aabaabb') == 'bbaabbbbaabbb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('aa', 'bbaab')
s = s.replace('abba', 'a')
return s
|
[
{
"method": "replace",
"args": [
"aa",
"bbaab"
]
},
{
"method": "replace",
"args": [
"abba",
"a"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaaa') == 'bbaabbbaab'
assert candidate('aaabaaaab') == 'bbaababbbaabbbaabb'
assert candidate('babb') == 'babb'
assert candidate('babbabb') == 'babb'
assert candidate('abab') == 'abab'
assert candidate('aabbbaa') == 'bbaabbbbbbaab'
assert candidate('bab') == 'bab'
assert candidate('aabaabb') == 'bbaabbbbaabbb'
# hidden tests
assert candidate('a') == 'a'
assert candidate('ababbbaabb') == 'ababbbbbaabbb'
assert candidate('abbbbbba') == 'abbbbbba'
assert candidate('baba') == 'baba'
assert candidate('abbbbaabb') == 'abbbbbbaabbb'
assert candidate('baabbabb') == 'bbbaabbbabb'
assert candidate('b') == 'b'
assert candidate('baababaaa') == 'bbbaabbbaaba'
assert candidate('b') == 'b'
assert candidate('babab') == 'babab'
assert candidate('bbbb') == 'bbbb'
assert candidate('aaa') == 'bbaaba'
assert candidate('baabaa') == 'bbbaabbbbaab'
assert candidate('aabbbbbba') == 'bbaabbbbbbba'
assert candidate('aabbb') == 'bbaabbbb'
assert candidate('bbbaabaa') == 'bbbbbaabbbbaab'
assert candidate('aba') == 'aba'
assert candidate('bbbb') == 'bbbb'
assert candidate('aaababaaa') == 'bbaabababbbaaba'
assert candidate('abbaaa') == 'abbbbaaba'
assert candidate('bbaaabbaa') == 'bbbbaababbbbaab'
assert candidate('aa') == 'bbaab'
assert candidate('bbb') == 'bbb'
assert candidate('ab') == 'ab'
assert candidate('ababaabba') == 'ababbbaabbba'
assert candidate('baaabb') == 'bbbaababb'
assert candidate('bb') == 'bb'
assert candidate('ba') == 'ba'
assert candidate('abaaababa') == 'abbbaabababa'
assert candidate('baaaaaaabb') == 'bbbaabbbaabbbaababb'
assert candidate('aab') == 'bbaabb'
assert candidate('a') == 'a'
| 40
|
[
{
"input": "aaaa",
"output": "bbaabbbaab"
},
{
"input": "aaabaaaab",
"output": "bbaababbbaabbbaabb"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "babbabb",
"output": "babb"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "aabbbaa",
"output": "bbaabbbbbbaab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aabaabb",
"output": "bbaabbbbaabbb"
}
] |
[
{
"input": "a",
"output": "a"
},
{
"input": "ababbbaabb",
"output": "ababbbbbaabbb"
},
{
"input": "abbbbbba",
"output": "abbbbbba"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "abbbbaabb",
"output": "abbbbbbaabbb"
},
{
"input": "baabbabb",
"output": "bbbaabbbabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "baababaaa",
"output": "bbbaabbbaaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "aaa",
"output": "bbaaba"
},
{
"input": "baabaa",
"output": "bbbaabbbbaab"
},
{
"input": "aabbbbbba",
"output": "bbaabbbbbbba"
},
{
"input": "aabbb",
"output": "bbaabbbb"
},
{
"input": "bbbaabaa",
"output": "bbbbbaabbbbaab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "aaababaaa",
"output": "bbaabababbbaaba"
},
{
"input": "abbaaa",
"output": "abbbbaaba"
},
{
"input": "bbaaabbaa",
"output": "bbbbaababbbbaab"
},
{
"input": "aa",
"output": "bbaab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ababaabba",
"output": "ababbbaabbba"
},
{
"input": "baaabb",
"output": "bbbaababb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abaaababa",
"output": "abbbaabababa"
},
{
"input": "baaaaaaabb",
"output": "bbbaabbbaabbbaababb"
},
{
"input": "aab",
"output": "bbaabb"
},
{
"input": "a",
"output": "a"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000069
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('baabbb') == 'baabbb'
>>> apply_pipeline('abbbb') == 'abbbb'
>>> apply_pipeline('abaaba') == 'abaaba'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('bababbbbba') == 'bababbbaaa'
>>> apply_pipeline('baaba') == 'baaba'
>>> apply_pipeline('aaaaaaaab') == 'aaaaaaaab'
>>> apply_pipeline('aaa') == 'aaa'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.lower()
s = s.replace('bba', 'aaa')
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bba",
"aaa"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baabbb') == 'baabbb'
assert candidate('abbbb') == 'abbbb'
assert candidate('abaaba') == 'abaaba'
assert candidate('a') == 'a'
assert candidate('bababbbbba') == 'bababbbaaa'
assert candidate('baaba') == 'baaba'
assert candidate('aaaaaaaab') == 'aaaaaaaab'
assert candidate('aaa') == 'aaa'
# hidden tests
assert candidate('ababbabaa') == 'abaaaabaa'
assert candidate('ab') == 'ab'
assert candidate('aaaabaaaa') == 'aaaabaaaa'
assert candidate('bababbbbab') == 'bababbaaab'
assert candidate('bbbbab') == 'bbaaab'
assert candidate('baab') == 'baab'
assert candidate('bbb') == 'bbb'
assert candidate('aba') == 'aba'
assert candidate('aabaab') == 'aabaab'
assert candidate('a') == 'a'
assert candidate('bbaab') == 'aaaab'
assert candidate('abb') == 'abb'
assert candidate('bbbbaab') == 'bbaaaab'
assert candidate('bbaaa') == 'aaaaa'
assert candidate('baaabbaa') == 'baaaaaaa'
assert candidate('abaaab') == 'abaaab'
assert candidate('abbaa') == 'aaaaa'
assert candidate('ab') == 'ab'
assert candidate('bb') == 'bb'
assert candidate('abbbbb') == 'abbbbb'
assert candidate('aaaba') == 'aaaba'
assert candidate('ba') == 'ba'
assert candidate('abba') == 'aaaa'
assert candidate('bbaaaaabab') == 'aaaaaaabab'
assert candidate('bbbba') == 'bbaaa'
assert candidate('abbaaabab') == 'aaaaaabab'
assert candidate('babbaabbaa') == 'baaaaaaaaa'
assert candidate('aaaa') == 'aaaa'
assert candidate('bbab') == 'aaab'
assert candidate('b') == 'b'
assert candidate('aababbbb') == 'aababbbb'
assert candidate('bbabaabb') == 'aaabaabb'
| 40
|
[
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "abaaba",
"output": "abaaba"
},
{
"input": "a",
"output": "a"
},
{
"input": "bababbbbba",
"output": "bababbbaaa"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "aaaaaaaab",
"output": "aaaaaaaab"
},
{
"input": "aaa",
"output": "aaa"
}
] |
[
{
"input": "ababbabaa",
"output": "abaaaabaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aaaabaaaa",
"output": "aaaabaaaa"
},
{
"input": "bababbbbab",
"output": "bababbaaab"
},
{
"input": "bbbbab",
"output": "bbaaab"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "aabaab",
"output": "aabaab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbaab",
"output": "aaaab"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbbbaab",
"output": "bbaaaab"
},
{
"input": "bbaaa",
"output": "aaaaa"
},
{
"input": "baaabbaa",
"output": "baaaaaaa"
},
{
"input": "abaaab",
"output": "abaaab"
},
{
"input": "abbaa",
"output": "aaaaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abbbbb",
"output": "abbbbb"
},
{
"input": "aaaba",
"output": "aaaba"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abba",
"output": "aaaa"
},
{
"input": "bbaaaaabab",
"output": "aaaaaaabab"
},
{
"input": "bbbba",
"output": "bbaaa"
},
{
"input": "abbaaabab",
"output": "aaaaaabab"
},
{
"input": "babbaabbaa",
"output": "baaaaaaaaa"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "bbab",
"output": "aaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aababbbb",
"output": "aababbbb"
},
{
"input": "bbabaabb",
"output": "aaabaabb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000070
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaabba') == 'bbaabba'
>>> apply_pipeline('baaaabb') == 'baaaabb'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('aa') == 'aa'
>>> apply_pipeline('aba') == 'aba'
>>> apply_pipeline('abba') == 'abba'
>>> apply_pipeline('aaababbba') == 'aaababbba'
>>> apply_pipeline('aaa') == 'aaa'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.upper()
s = s.lower()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaabba') == 'bbaabba'
assert candidate('baaaabb') == 'baaaabb'
assert candidate('abbb') == 'abbb'
assert candidate('aa') == 'aa'
assert candidate('aba') == 'aba'
assert candidate('abba') == 'abba'
assert candidate('aaababbba') == 'aaababbba'
assert candidate('aaa') == 'aaa'
# hidden tests
assert candidate('aababa') == 'aababa'
assert candidate('baabbbab') == 'baabbbab'
assert candidate('aabbba') == 'aabbba'
assert candidate('abaaabba') == 'abaaabba'
assert candidate('aab') == 'aab'
assert candidate('bbabababaa') == 'bbabababaa'
assert candidate('ababa') == 'ababa'
assert candidate('bab') == 'bab'
assert candidate('aa') == 'aa'
assert candidate('babbaab') == 'babbaab'
assert candidate('bbbbbba') == 'bbbbbba'
assert candidate('aaba') == 'aaba'
assert candidate('bbabaabaaa') == 'bbabaabaaa'
assert candidate('a') == 'a'
assert candidate('babababb') == 'babababb'
assert candidate('bbbbaaaab') == 'bbbbaaaab'
assert candidate('bb') == 'bb'
assert candidate('bbbb') == 'bbbb'
assert candidate('abababaa') == 'abababaa'
assert candidate('abbbbbab') == 'abbbbbab'
assert candidate('aa') == 'aa'
assert candidate('aabaaaaabb') == 'aabaaaaabb'
assert candidate('bbaaa') == 'bbaaa'
assert candidate('bbababaa') == 'bbababaa'
assert candidate('baabbab') == 'baabbab'
assert candidate('b') == 'b'
assert candidate('abbbaaabb') == 'abbbaaabb'
assert candidate('abbbabba') == 'abbbabba'
assert candidate('aaaaabab') == 'aaaaabab'
assert candidate('aabbb') == 'aabbb'
assert candidate('bbbabaaaaa') == 'bbbabaaaaa'
assert candidate('bbababaa') == 'bbababaa'
| 40
|
[
{
"input": "bbaabba",
"output": "bbaabba"
},
{
"input": "baaaabb",
"output": "baaaabb"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "aaababbba",
"output": "aaababbba"
},
{
"input": "aaa",
"output": "aaa"
}
] |
[
{
"input": "aababa",
"output": "aababa"
},
{
"input": "baabbbab",
"output": "baabbbab"
},
{
"input": "aabbba",
"output": "aabbba"
},
{
"input": "abaaabba",
"output": "abaaabba"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbabababaa",
"output": "bbabababaa"
},
{
"input": "ababa",
"output": "ababa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "babbaab",
"output": "babbaab"
},
{
"input": "bbbbbba",
"output": "bbbbbba"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "bbabaabaaa",
"output": "bbabaabaaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "babababb",
"output": "babababb"
},
{
"input": "bbbbaaaab",
"output": "bbbbaaaab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "abababaa",
"output": "abababaa"
},
{
"input": "abbbbbab",
"output": "abbbbbab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabaaaaabb",
"output": "aabaaaaabb"
},
{
"input": "bbaaa",
"output": "bbaaa"
},
{
"input": "bbababaa",
"output": "bbababaa"
},
{
"input": "baabbab",
"output": "baabbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbbaaabb",
"output": "abbbaaabb"
},
{
"input": "abbbabba",
"output": "abbbabba"
},
{
"input": "aaaaabab",
"output": "aaaaabab"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"input": "bbbabaaaaa",
"output": "bbbabaaaaa"
},
{
"input": "bbababaa",
"output": "bbababaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000071
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabaaa') == 'AbbbAAA'
>>> apply_pipeline('bbbabbaa') == 'BBBbbbBAA'
>>> apply_pipeline('bbbab') == 'BBBbbb'
>>> apply_pipeline('bbbaaa') == 'BBBAAA'
>>> apply_pipeline('bbbabb') == 'BBBbbbB'
>>> apply_pipeline('bab') == 'Bbbb'
>>> apply_pipeline('aabaaaa') == 'AbbbAAAA'
>>> apply_pipeline('b') == 'B'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('AB', 'bbb')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AB",
"bbb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabaaa') == 'AbbbAAA'
assert candidate('bbbabbaa') == 'BBBbbbBAA'
assert candidate('bbbab') == 'BBBbbb'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('bbbabb') == 'BBBbbbB'
assert candidate('bab') == 'Bbbb'
assert candidate('aabaaaa') == 'AbbbAAAA'
assert candidate('b') == 'B'
# hidden tests
assert candidate('abbbbaab') == 'bbbBBBAbbb'
assert candidate('aabbaaabab') == 'AbbbBAAbbbbbb'
assert candidate('a') == 'A'
assert candidate('b') == 'B'
assert candidate('aaaaba') == 'AAAbbbA'
assert candidate('aab') == 'Abbb'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('babaaaabaa') == 'BbbbAAAbbbAA'
assert candidate('abbbabbbb') == 'bbbBBbbbBBB'
assert candidate('baaa') == 'BAAA'
assert candidate('aabab') == 'Abbbbbb'
assert candidate('bbbabbb') == 'BBBbbbBB'
assert candidate('b') == 'B'
assert candidate('aabbbabb') == 'AbbbBBbbbB'
assert candidate('abbbbabbb') == 'bbbBBBbbbBB'
assert candidate('bb') == 'BB'
assert candidate('abaabbb') == 'bbbAbbbBB'
assert candidate('baabaab') == 'BAbbbAbbb'
assert candidate('abbbbbaaaa') == 'bbbBBBBAAAA'
assert candidate('aaabbbaaaa') == 'AAbbbBBAAAA'
assert candidate('aabbabaa') == 'AbbbBbbbAA'
assert candidate('bbbbbaabb') == 'BBBBBAbbbB'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('baabbaabb') == 'BAbbbBAbbbB'
assert candidate('bbbabaa') == 'BBBbbbAA'
assert candidate('abbabbba') == 'bbbBbbbBBA'
assert candidate('baaab') == 'BAAbbb'
assert candidate('abb') == 'bbbB'
assert candidate('babaa') == 'BbbbAA'
assert candidate('baab') == 'BAbbb'
assert candidate('b') == 'B'
assert candidate('baaabba') == 'BAAbbbBA'
| 40
|
[
{
"input": "aabaaa",
"output": "AbbbAAA"
},
{
"input": "bbbabbaa",
"output": "BBBbbbBAA"
},
{
"input": "bbbab",
"output": "BBBbbb"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "bbbabb",
"output": "BBBbbbB"
},
{
"input": "bab",
"output": "Bbbb"
},
{
"input": "aabaaaa",
"output": "AbbbAAAA"
},
{
"input": "b",
"output": "B"
}
] |
[
{
"input": "abbbbaab",
"output": "bbbBBBAbbb"
},
{
"input": "aabbaaabab",
"output": "AbbbBAAbbbbbb"
},
{
"input": "a",
"output": "A"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaaba",
"output": "AAAbbbA"
},
{
"input": "aab",
"output": "Abbb"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "babaaaabaa",
"output": "BbbbAAAbbbAA"
},
{
"input": "abbbabbbb",
"output": "bbbBBbbbBBB"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "aabab",
"output": "Abbbbbb"
},
{
"input": "bbbabbb",
"output": "BBBbbbBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabbbabb",
"output": "AbbbBBbbbB"
},
{
"input": "abbbbabbb",
"output": "bbbBBBbbbBB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "abaabbb",
"output": "bbbAbbbBB"
},
{
"input": "baabaab",
"output": "BAbbbAbbb"
},
{
"input": "abbbbbaaaa",
"output": "bbbBBBBAAAA"
},
{
"input": "aaabbbaaaa",
"output": "AAbbbBBAAAA"
},
{
"input": "aabbabaa",
"output": "AbbbBbbbAA"
},
{
"input": "bbbbbaabb",
"output": "BBBBBAbbbB"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "baabbaabb",
"output": "BAbbbBAbbbB"
},
{
"input": "bbbabaa",
"output": "BBBbbbAA"
},
{
"input": "abbabbba",
"output": "bbbBbbbBBA"
},
{
"input": "baaab",
"output": "BAAbbb"
},
{
"input": "abb",
"output": "bbbB"
},
{
"input": "babaa",
"output": "BbbbAA"
},
{
"input": "baab",
"output": "BAbbb"
},
{
"input": "b",
"output": "B"
},
{
"input": "baaabba",
"output": "BAAbbbBA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000072
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaaaab') == 'BBAAAAB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('bb') == 'BB'
>>> apply_pipeline('baaabbba') == 'BAAABBBA'
>>> apply_pipeline('aabaaabb') == 'AABAAABB'
>>> apply_pipeline('aba') == 'ABA'
>>> 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('bbaaaab') == 'BBAAAAB'
assert candidate('a') == 'A'
assert candidate('aa') == 'AA'
assert candidate('bb') == 'BB'
assert candidate('baaabbba') == 'BAAABBBA'
assert candidate('aabaaabb') == 'AABAAABB'
assert candidate('aba') == 'ABA'
assert candidate('bb') == 'BB'
# hidden tests
assert candidate('baa') == 'BAA'
assert candidate('babb') == 'BABB'
assert candidate('abbbbab') == 'ABBBBAB'
assert candidate('abaaaaabba') == 'ABAAAAABBA'
assert candidate('aaababb') == 'AAABABB'
assert candidate('abbabbbb') == 'ABBABBBB'
assert candidate('bab') == 'BAB'
assert candidate('abbbabba') == 'ABBBABBA'
assert candidate('b') == 'B'
assert candidate('bbaabaaba') == 'BBAABAABA'
assert candidate('baa') == 'BAA'
assert candidate('baaaabaab') == 'BAAAABAAB'
assert candidate('aabaaaabba') == 'AABAAAABBA'
assert candidate('abbbbbaab') == 'ABBBBBAAB'
assert candidate('babaaabbbb') == 'BABAAABBBB'
assert candidate('abbabbb') == 'ABBABBB'
assert candidate('aaaabaabba') == 'AAAABAABBA'
assert candidate('bbabaabbab') == 'BBABAABBAB'
assert candidate('bbbabaaa') == 'BBBABAAA'
assert candidate('bbbbbbab') == 'BBBBBBAB'
assert candidate('bbaabbbaab') == 'BBAABBBAAB'
assert candidate('aaa') == 'AAA'
assert candidate('b') == 'B'
assert candidate('baabb') == 'BAABB'
assert candidate('ab') == 'AB'
assert candidate('aabaaaaaba') == 'AABAAAAABA'
assert candidate('b') == 'B'
assert candidate('abbaabb') == 'ABBAABB'
assert candidate('baa') == 'BAA'
assert candidate('bbb') == 'BBB'
assert candidate('aaaababb') == 'AAAABABB'
assert candidate('ba') == 'BA'
| 40
|
[
{
"input": "bbaaaab",
"output": "BBAAAAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaabbba",
"output": "BAAABBBA"
},
{
"input": "aabaaabb",
"output": "AABAAABB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "bb",
"output": "BB"
}
] |
[
{
"input": "baa",
"output": "BAA"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "abbbbab",
"output": "ABBBBAB"
},
{
"input": "abaaaaabba",
"output": "ABAAAAABBA"
},
{
"input": "aaababb",
"output": "AAABABB"
},
{
"input": "abbabbbb",
"output": "ABBABBBB"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "abbbabba",
"output": "ABBBABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaabaaba",
"output": "BBAABAABA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "baaaabaab",
"output": "BAAAABAAB"
},
{
"input": "aabaaaabba",
"output": "AABAAAABBA"
},
{
"input": "abbbbbaab",
"output": "ABBBBBAAB"
},
{
"input": "babaaabbbb",
"output": "BABAAABBBB"
},
{
"input": "abbabbb",
"output": "ABBABBB"
},
{
"input": "aaaabaabba",
"output": "AAAABAABBA"
},
{
"input": "bbabaabbab",
"output": "BBABAABBAB"
},
{
"input": "bbbabaaa",
"output": "BBBABAAA"
},
{
"input": "bbbbbbab",
"output": "BBBBBBAB"
},
{
"input": "bbaabbbaab",
"output": "BBAABBBAAB"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "baabb",
"output": "BAABB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "aabaaaaaba",
"output": "AABAAAAABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "abbaabb",
"output": "ABBAABB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aaaababb",
"output": "AAAABABB"
},
{
"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/000073
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaaab') == 'babababab'
>>> apply_pipeline('babaa') == 'bbababbba'
>>> apply_pipeline('aabbbbaa') == 'bababbbbabbba'
>>> apply_pipeline('bbababbb') == 'bbbabbabbb'
>>> apply_pipeline('bbb') == 'bbb'
>>> apply_pipeline('bab') == 'bbab'
>>> apply_pipeline('bbbbab') == 'bbbbbab'
>>> apply_pipeline('aabb') == 'bababb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('baa', 'abba')
s = s.replace('a', 'ba')
s = s.lower()
s = s.lower()
return s
|
[
{
"method": "replace",
"args": [
"baa",
"abba"
]
},
{
"method": "replace",
"args": [
"a",
"ba"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaaab') == 'babababab'
assert candidate('babaa') == 'bbababbba'
assert candidate('aabbbbaa') == 'bababbbbabbba'
assert candidate('bbababbb') == 'bbbabbabbb'
assert candidate('bbb') == 'bbb'
assert candidate('bab') == 'bbab'
assert candidate('bbbbab') == 'bbbbbab'
assert candidate('aabb') == 'bababb'
# hidden tests
assert candidate('aa') == 'baba'
assert candidate('bb') == 'bb'
assert candidate('a') == 'ba'
assert candidate('b') == 'b'
assert candidate('bbbbb') == 'bbbbb'
assert candidate('aabaaabbb') == 'babababbbababbb'
assert candidate('abbbabaaaa') == 'babbbbababbbababa'
assert candidate('aa') == 'baba'
assert candidate('b') == 'b'
assert candidate('aab') == 'babab'
assert candidate('aababaa') == 'bababbababbba'
assert candidate('bba') == 'bbba'
assert candidate('baaaaab') == 'babbbabababab'
assert candidate('baab') == 'babbbab'
assert candidate('abbbabaa') == 'babbbbababbba'
assert candidate('bbbbbabbaa') == 'bbbbbbabbabbba'
assert candidate('b') == 'b'
assert candidate('abaaaa') == 'bababbbababa'
assert candidate('b') == 'b'
assert candidate('ab') == 'bab'
assert candidate('bba') == 'bbba'
assert candidate('babbba') == 'bbabbbba'
assert candidate('aabbaba') == 'bababbbabba'
assert candidate('aaab') == 'bababab'
assert candidate('abba') == 'babbba'
assert candidate('abaabbaa') == 'bababbbabbabbba'
assert candidate('baaabaaab') == 'babbbabababbbabab'
assert candidate('bbab') == 'bbbab'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('babbbabb') == 'bbabbbbabb'
assert candidate('bbaaaab') == 'bbabbbababab'
| 40
|
[
{
"input": "aaaab",
"output": "babababab"
},
{
"input": "babaa",
"output": "bbababbba"
},
{
"input": "aabbbbaa",
"output": "bababbbbabbba"
},
{
"input": "bbababbb",
"output": "bbbabbabbb"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bab",
"output": "bbab"
},
{
"input": "bbbbab",
"output": "bbbbbab"
},
{
"input": "aabb",
"output": "bababb"
}
] |
[
{
"input": "aa",
"output": "baba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "a",
"output": "ba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbbbb",
"output": "bbbbb"
},
{
"input": "aabaaabbb",
"output": "babababbbababbb"
},
{
"input": "abbbabaaaa",
"output": "babbbbababbbababa"
},
{
"input": "aa",
"output": "baba"
},
{
"input": "b",
"output": "b"
},
{
"input": "aab",
"output": "babab"
},
{
"input": "aababaa",
"output": "bababbababbba"
},
{
"input": "bba",
"output": "bbba"
},
{
"input": "baaaaab",
"output": "babbbabababab"
},
{
"input": "baab",
"output": "babbbab"
},
{
"input": "abbbabaa",
"output": "babbbbababbba"
},
{
"input": "bbbbbabbaa",
"output": "bbbbbbabbabbba"
},
{
"input": "b",
"output": "b"
},
{
"input": "abaaaa",
"output": "bababbbababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "ab",
"output": "bab"
},
{
"input": "bba",
"output": "bbba"
},
{
"input": "babbba",
"output": "bbabbbba"
},
{
"input": "aabbaba",
"output": "bababbbabba"
},
{
"input": "aaab",
"output": "bababab"
},
{
"input": "abba",
"output": "babbba"
},
{
"input": "abaabbaa",
"output": "bababbbabbabbba"
},
{
"input": "baaabaaab",
"output": "babbbabababbbabab"
},
{
"input": "bbab",
"output": "bbbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "babbbabb",
"output": "bbabbbbabb"
},
{
"input": "bbaaaab",
"output": "bbabbbababab"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000074
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babb') == 'BABB'
>>> apply_pipeline('baaa') == 'a'
>>> apply_pipeline('bbbb') == 'BBBB'
>>> apply_pipeline('bbaa') == 'BBAA'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('aa') == 'AA'
>>> apply_pipeline('ab') == 'AB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('BAAA', 'a')
s = s.replace('BABA', 'a')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAAA",
"a"
]
},
{
"method": "replace",
"args": [
"BABA",
"a"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babb') == 'BABB'
assert candidate('baaa') == 'a'
assert candidate('bbbb') == 'BBBB'
assert candidate('bbaa') == 'BBAA'
assert candidate('ab') == 'AB'
assert candidate('bbb') == 'BBB'
assert candidate('aa') == 'AA'
assert candidate('ab') == 'AB'
# hidden tests
assert candidate('baab') == 'BAAB'
assert candidate('bbaaabbbba') == 'BaBBBBA'
assert candidate('ababaabbba') == 'AaABBBA'
assert candidate('abab') == 'ABAB'
assert candidate('ababb') == 'ABABB'
assert candidate('aaababab') == 'AAAaB'
assert candidate('baabbbbab') == 'BAABBBBAB'
assert candidate('babbb') == 'BABBB'
assert candidate('aaaaabaa') == 'AAAAABAA'
assert candidate('abbaa') == 'ABBAA'
assert candidate('bba') == 'BBA'
assert candidate('bbabaabb') == 'BaABB'
assert candidate('babbbab') == 'BABBBAB'
assert candidate('bbb') == 'BBB'
assert candidate('b') == 'B'
assert candidate('bbaaaabbaa') == 'BaABBAA'
assert candidate('abba') == 'ABBA'
assert candidate('baaba') == 'BAABA'
assert candidate('bbb') == 'BBB'
assert candidate('bbaaabaab') == 'BaBAAB'
assert candidate('abbabbab') == 'ABBABBAB'
assert candidate('aaaaabbaa') == 'AAAAABBAA'
assert candidate('abbb') == 'ABBB'
assert candidate('aaabba') == 'AAABBA'
assert candidate('aaababba') == 'AAABABBA'
assert candidate('bbb') == 'BBB'
assert candidate('ababa') == 'Aa'
assert candidate('aaaaab') == 'AAAAAB'
assert candidate('aaaaa') == 'AAAAA'
assert candidate('b') == 'B'
assert candidate('b') == 'B'
assert candidate('ab') == 'AB'
| 40
|
[
{
"input": "babb",
"output": "BABB"
},
{
"input": "baaa",
"output": "a"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "ab",
"output": "AB"
}
] |
[
{
"input": "baab",
"output": "BAAB"
},
{
"input": "bbaaabbbba",
"output": "BaBBBBA"
},
{
"input": "ababaabbba",
"output": "AaABBBA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "ababb",
"output": "ABABB"
},
{
"input": "aaababab",
"output": "AAAaB"
},
{
"input": "baabbbbab",
"output": "BAABBBBAB"
},
{
"input": "babbb",
"output": "BABBB"
},
{
"input": "aaaaabaa",
"output": "AAAAABAA"
},
{
"input": "abbaa",
"output": "ABBAA"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "bbabaabb",
"output": "BaABB"
},
{
"input": "babbbab",
"output": "BABBBAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaaaabbaa",
"output": "BaABBAA"
},
{
"input": "abba",
"output": "ABBA"
},
{
"input": "baaba",
"output": "BAABA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "bbaaabaab",
"output": "BaBAAB"
},
{
"input": "abbabbab",
"output": "ABBABBAB"
},
{
"input": "aaaaabbaa",
"output": "AAAAABBAA"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "aaabba",
"output": "AAABBA"
},
{
"input": "aaababba",
"output": "AAABABBA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "ababa",
"output": "Aa"
},
{
"input": "aaaaab",
"output": "AAAAAB"
},
{
"input": "aaaaa",
"output": "AAAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "ab",
"output": "AB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000075
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbbb') == 'ABAABBB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('baab') == 'BAAB'
>>> apply_pipeline('bab') == 'BAB'
>>> apply_pipeline('bbbbbbbaab') == 'BAABBBAABBBAAB'
>>> apply_pipeline('babbabbaab') == 'BABBABBAAB'
>>> apply_pipeline('aaabaaabba') == 'AAABAAABBA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('babab', 'b')
s = s.replace('bbb', 'baabb')
s = s.upper()
s = s.upper()
s = s.upper()
return s
|
[
{
"method": "replace",
"args": [
"babab",
"b"
]
},
{
"method": "replace",
"args": [
"bbb",
"baabb"
]
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abbbb') == 'ABAABBB'
assert candidate('b') == 'B'
assert candidate('a') == 'A'
assert candidate('baab') == 'BAAB'
assert candidate('bab') == 'BAB'
assert candidate('bbbbbbbaab') == 'BAABBBAABBBAAB'
assert candidate('babbabbaab') == 'BABBABBAAB'
assert candidate('aaabaaabba') == 'AAABAAABBA'
# hidden tests
assert candidate('aba') == 'ABA'
assert candidate('bbbab') == 'BAABBAB'
assert candidate('bb') == 'BB'
assert candidate('aaabaaaa') == 'AAABAAAA'
assert candidate('baababaab') == 'BAABABAAB'
assert candidate('aaababab') == 'AAAB'
assert candidate('baabbaaba') == 'BAABBAABA'
assert candidate('a') == 'A'
assert candidate('aaabaaab') == 'AAABAAAB'
assert candidate('aabbaa') == 'AABBAA'
assert candidate('aabb') == 'AABB'
assert candidate('abbbaa') == 'ABAABBAA'
assert candidate('aaa') == 'AAA'
assert candidate('ababbaa') == 'ABABBAA'
assert candidate('aaaab') == 'AAAAB'
assert candidate('bbbbbbbab') == 'BAABBBAABBBAB'
assert candidate('abbabbaabb') == 'ABBABBAABB'
assert candidate('bbababbaab') == 'BAABBAAB'
assert candidate('aba') == 'ABA'
assert candidate('bbabbaabb') == 'BBABBAABB'
assert candidate('ababa') == 'ABABA'
assert candidate('bbbabbb') == 'BAABBABAABB'
assert candidate('bbbaaabbb') == 'BAABBAAABAABB'
assert candidate('bba') == 'BBA'
assert candidate('babbabbaa') == 'BABBABBAA'
assert candidate('baa') == 'BAA'
assert candidate('bbababa') == 'BBA'
assert candidate('babab') == 'B'
assert candidate('abbabbbaba') == 'ABBABAABBABA'
assert candidate('a') == 'A'
assert candidate('bab') == 'BAB'
assert candidate('aabbbaaa') == 'AABAABBAAA'
| 40
|
[
{
"input": "abbbb",
"output": "ABAABBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "a",
"output": "A"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "bbbbbbbaab",
"output": "BAABBBAABBBAAB"
},
{
"input": "babbabbaab",
"output": "BABBABBAAB"
},
{
"input": "aaabaaabba",
"output": "AAABAAABBA"
}
] |
[
{
"input": "aba",
"output": "ABA"
},
{
"input": "bbbab",
"output": "BAABBAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aaabaaaa",
"output": "AAABAAAA"
},
{
"input": "baababaab",
"output": "BAABABAAB"
},
{
"input": "aaababab",
"output": "AAAB"
},
{
"input": "baabbaaba",
"output": "BAABBAABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaabaaab",
"output": "AAABAAAB"
},
{
"input": "aabbaa",
"output": "AABBAA"
},
{
"input": "aabb",
"output": "AABB"
},
{
"input": "abbbaa",
"output": "ABAABBAA"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "ababbaa",
"output": "ABABBAA"
},
{
"input": "aaaab",
"output": "AAAAB"
},
{
"input": "bbbbbbbab",
"output": "BAABBBAABBBAB"
},
{
"input": "abbabbaabb",
"output": "ABBABBAABB"
},
{
"input": "bbababbaab",
"output": "BAABBAAB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "bbabbaabb",
"output": "BBABBAABB"
},
{
"input": "ababa",
"output": "ABABA"
},
{
"input": "bbbabbb",
"output": "BAABBABAABB"
},
{
"input": "bbbaaabbb",
"output": "BAABBAAABAABB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "babbabbaa",
"output": "BABBABBAA"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "bbababa",
"output": "BBA"
},
{
"input": "babab",
"output": "B"
},
{
"input": "abbabbbaba",
"output": "ABBABAABBABA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "aabbbaaa",
"output": "AABAABBAAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000076
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bb') == 'bb'
>>> apply_pipeline('abbbaaaa') == 'abbbaaaa'
>>> apply_pipeline('aaaaaaaaba') == 'aaaaaaaaba'
>>> apply_pipeline('babababba') == 'babababba'
>>> apply_pipeline('babaababb') == 'babaababb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('babbbbba') == 'babbbbba'
"""
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('bb') == 'bb'
assert candidate('bb') == 'bb'
assert candidate('abbbaaaa') == 'abbbaaaa'
assert candidate('aaaaaaaaba') == 'aaaaaaaaba'
assert candidate('babababba') == 'babababba'
assert candidate('babaababb') == 'babaababb'
assert candidate('b') == 'b'
assert candidate('babbbbba') == 'babbbbba'
# hidden tests
assert candidate('ba') == 'ba'
assert candidate('abbbb') == 'abbbb'
assert candidate('abababaa') == 'abababaa'
assert candidate('bbbbaa') == 'bbbbaa'
assert candidate('bbbababba') == 'bbbababba'
assert candidate('ab') == 'ab'
assert candidate('bbb') == 'bbb'
assert candidate('baabbabb') == 'baabbabb'
assert candidate('bb') == 'bb'
assert candidate('bbaa') == 'bbaa'
assert candidate('a') == 'a'
assert candidate('aabaaaba') == 'aabaaaba'
assert candidate('aa') == 'aa'
assert candidate('aabbba') == 'aabbba'
assert candidate('bbaaa') == 'bbaaa'
assert candidate('bb') == 'bb'
assert candidate('baaabaa') == 'baaabaa'
assert candidate('aabab') == 'aabab'
assert candidate('abaa') == 'abaa'
assert candidate('b') == 'b'
assert candidate('bbabaa') == 'bbabaa'
assert candidate('bba') == 'bba'
assert candidate('abbbaa') == 'abbbaa'
assert candidate('aaba') == 'aaba'
assert candidate('bba') == 'bba'
assert candidate('aaaab') == 'aaaab'
assert candidate('aaabaabb') == 'aaabaabb'
assert candidate('bbbb') == 'bbbb'
assert candidate('bbaba') == 'bbaba'
assert candidate('bbabbbab') == 'bbabbbab'
assert candidate('aabbbaba') == 'aabbbaba'
assert candidate('aababaaaba') == 'aababaaaba'
| 40
|
[
{
"input": "bb",
"output": "bb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abbbaaaa",
"output": "abbbaaaa"
},
{
"input": "aaaaaaaaba",
"output": "aaaaaaaaba"
},
{
"input": "babababba",
"output": "babababba"
},
{
"input": "babaababb",
"output": "babaababb"
},
{
"input": "b",
"output": "b"
},
{
"input": "babbbbba",
"output": "babbbbba"
}
] |
[
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "abababaa",
"output": "abababaa"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "bbbababba",
"output": "bbbababba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "baabbabb",
"output": "baabbabb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabaaaba",
"output": "aabaaaba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabbba",
"output": "aabbba"
},
{
"input": "bbaaa",
"output": "bbaaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "baaabaa",
"output": "baaabaa"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbabaa",
"output": "bbabaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abbbaa",
"output": "abbbaa"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aaaab",
"output": "aaaab"
},
{
"input": "aaabaabb",
"output": "aaabaabb"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "bbabbbab",
"output": "bbabbbab"
},
{
"input": "aabbbaba",
"output": "aabbbaba"
},
{
"input": "aababaaaba",
"output": "aababaaaba"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000077
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaabba') == 'aaabba'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('abbbaaaab') == 'abbbaaaab'
>>> apply_pipeline('aba') == 'aba'
>>> apply_pipeline('aaaa') == 'aaaa'
>>> apply_pipeline('aab') == 'aab'
>>> apply_pipeline('bbb') == 'bbb'
>>> apply_pipeline('babbbaaa') == 'babbbaaa'
"""
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('aaabba') == 'aaabba'
assert candidate('abbb') == 'abbb'
assert candidate('abbbaaaab') == 'abbbaaaab'
assert candidate('aba') == 'aba'
assert candidate('aaaa') == 'aaaa'
assert candidate('aab') == 'aab'
assert candidate('bbb') == 'bbb'
assert candidate('babbbaaa') == 'babbbaaa'
# hidden tests
assert candidate('abab') == 'abab'
assert candidate('bbaababb') == 'bbaababb'
assert candidate('bbbbaba') == 'bbbbaba'
assert candidate('babababbab') == 'babababbab'
assert candidate('ababbaa') == 'ababbaa'
assert candidate('bba') == 'bba'
assert candidate('abbababb') == 'abbababb'
assert candidate('aab') == 'aab'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('abbaab') == 'abbaab'
assert candidate('babbabbba') == 'babbabbba'
assert candidate('babb') == 'babb'
assert candidate('aabbaaa') == 'aabbaaa'
assert candidate('aa') == 'aa'
assert candidate('ba') == 'ba'
assert candidate('bbaaa') == 'bbaaa'
assert candidate('baaaaaaa') == 'baaaaaaa'
assert candidate('aabaaaa') == 'aabaaaa'
assert candidate('abaa') == 'abaa'
assert candidate('aa') == 'aa'
assert candidate('aabaaaa') == 'aabaaaa'
assert candidate('aaaabbaa') == 'aaaabbaa'
assert candidate('ab') == 'ab'
assert candidate('aaabbbbaaa') == 'aaabbbbaaa'
assert candidate('ab') == 'ab'
assert candidate('baabbab') == 'baabbab'
assert candidate('baba') == 'baba'
assert candidate('bbbbaa') == 'bbbbaa'
assert candidate('abaabaaa') == 'abaabaaa'
assert candidate('aaaaa') == 'aaaaa'
assert candidate('aaaaa') == 'aaaaa'
assert candidate('aabaaba') == 'aabaaba'
| 40
|
[
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "abbbaaaab",
"output": "abbbaaaab"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "babbbaaa",
"output": "babbbaaa"
}
] |
[
{
"input": "abab",
"output": "abab"
},
{
"input": "bbaababb",
"output": "bbaababb"
},
{
"input": "bbbbaba",
"output": "bbbbaba"
},
{
"input": "babababbab",
"output": "babababbab"
},
{
"input": "ababbaa",
"output": "ababbaa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abbababb",
"output": "abbababb"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "abbaab",
"output": "abbaab"
},
{
"input": "babbabbba",
"output": "babbabbba"
},
{
"input": "babb",
"output": "babb"
},
{
"input": "aabbaaa",
"output": "aabbaaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bbaaa",
"output": "bbaaa"
},
{
"input": "baaaaaaa",
"output": "baaaaaaa"
},
{
"input": "aabaaaa",
"output": "aabaaaa"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabaaaa",
"output": "aabaaaa"
},
{
"input": "aaaabbaa",
"output": "aaaabbaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aaabbbbaaa",
"output": "aaabbbbaaa"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "baabbab",
"output": "baabbab"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "abaabaaa",
"output": "abaabaaa"
},
{
"input": "aaaaa",
"output": "aaaaa"
},
{
"input": "aaaaa",
"output": "aaaaa"
},
{
"input": "aabaaba",
"output": "aabaaba"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000078
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaaabbaaa') == 'BaaAaaaaAA'
>>> apply_pipeline('bbbbbb') == 'BBBBBB'
>>> apply_pipeline('bbaabbb') == 'BaaaaBB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('aababbaba') == 'AaaaaaaBA'
>>> apply_pipeline('aabababbab') == 'AaaaaaaaaB'
>>> apply_pipeline('bbbbbaa') == 'BBBBaaA'
>>> apply_pipeline('baaaabbb') == 'BAAAaaBB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bba', 'bab')
s = s.upper()
s = s.replace('AB', 'aa')
return s
|
[
{
"method": "replace",
"args": [
"bba",
"bab"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AB",
"aa"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaabbaaa') == 'BaaAaaaaAA'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('bbaabbb') == 'BaaaaBB'
assert candidate('a') == 'A'
assert candidate('aababbaba') == 'AaaaaaaBA'
assert candidate('aabababbab') == 'AaaaaaaaaB'
assert candidate('bbbbbaa') == 'BBBBaaA'
assert candidate('baaaabbb') == 'BAAAaaBB'
# hidden tests
assert candidate('a') == 'A'
assert candidate('bbabbbbbab') == 'BaaBBBBaaB'
assert candidate('abbb') == 'aaBB'
assert candidate('aab') == 'Aaa'
assert candidate('baababaa') == 'BAaaaaAA'
assert candidate('abaaa') == 'aaAAA'
assert candidate('baabaab') == 'BAaaAaa'
assert candidate('abb') == 'aaB'
assert candidate('bbab') == 'BaaB'
assert candidate('baba') == 'BaaA'
assert candidate('abba') == 'aaaa'
assert candidate('bbbba') == 'BBBaa'
assert candidate('abbaa') == 'aaaaA'
assert candidate('ab') == 'aa'
assert candidate('bbbbbb') == 'BBBBBB'
assert candidate('aba') == 'aaA'
assert candidate('baaba') == 'BAaaA'
assert candidate('aab') == 'Aaa'
assert candidate('babbb') == 'BaaBB'
assert candidate('bab') == 'Baa'
assert candidate('ababbaba') == 'aaaaaaBA'
assert candidate('a') == 'A'
assert candidate('babbaabb') == 'BaaaaaaB'
assert candidate('aaabbabbaa') == 'AAaaaaBaaA'
assert candidate('a') == 'A'
assert candidate('bbb') == 'BBB'
assert candidate('bbab') == 'BaaB'
assert candidate('aabb') == 'AaaB'
assert candidate('b') == 'B'
assert candidate('baabbab') == 'BAaaaaB'
assert candidate('aaaba') == 'AAaaA'
assert candidate('bababba') == 'Baaaaaa'
| 40
|
[
{
"input": "bbaaabbaaa",
"output": "BaaAaaaaAA"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "bbaabbb",
"output": "BaaaaBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "aababbaba",
"output": "AaaaaaaBA"
},
{
"input": "aabababbab",
"output": "AaaaaaaaaB"
},
{
"input": "bbbbbaa",
"output": "BBBBaaA"
},
{
"input": "baaaabbb",
"output": "BAAAaaBB"
}
] |
[
{
"input": "a",
"output": "A"
},
{
"input": "bbabbbbbab",
"output": "BaaBBBBaaB"
},
{
"input": "abbb",
"output": "aaBB"
},
{
"input": "aab",
"output": "Aaa"
},
{
"input": "baababaa",
"output": "BAaaaaAA"
},
{
"input": "abaaa",
"output": "aaAAA"
},
{
"input": "baabaab",
"output": "BAaaAaa"
},
{
"input": "abb",
"output": "aaB"
},
{
"input": "bbab",
"output": "BaaB"
},
{
"input": "baba",
"output": "BaaA"
},
{
"input": "abba",
"output": "aaaa"
},
{
"input": "bbbba",
"output": "BBBaa"
},
{
"input": "abbaa",
"output": "aaaaA"
},
{
"input": "ab",
"output": "aa"
},
{
"input": "bbbbbb",
"output": "BBBBBB"
},
{
"input": "aba",
"output": "aaA"
},
{
"input": "baaba",
"output": "BAaaA"
},
{
"input": "aab",
"output": "Aaa"
},
{
"input": "babbb",
"output": "BaaBB"
},
{
"input": "bab",
"output": "Baa"
},
{
"input": "ababbaba",
"output": "aaaaaaBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "babbaabb",
"output": "BaaaaaaB"
},
{
"input": "aaabbabbaa",
"output": "AAaaaaBaaA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "bbab",
"output": "BaaB"
},
{
"input": "aabb",
"output": "AaaB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baabbab",
"output": "BAaaaaB"
},
{
"input": "aaaba",
"output": "AAaaA"
},
{
"input": "bababba",
"output": "Baaaaaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000079
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbbababab') == 'bbababab'
>>> apply_pipeline('aabbbaa') == 'abbaa'
>>> apply_pipeline('bbabaaab') == 'bbabaaab'
>>> apply_pipeline('babbaaaa') == 'bbaaaa'
>>> apply_pipeline('abbbaabb') == 'bbab'
>>> apply_pipeline('bab') == 'bab'
>>> apply_pipeline('a') == 'a'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('abb', 'b')
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abb",
"b"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('ba') == 'ba'
assert candidate('abbbababab') == 'bbababab'
assert candidate('aabbbaa') == 'abbaa'
assert candidate('bbabaaab') == 'bbabaaab'
assert candidate('babbaaaa') == 'bbaaaa'
assert candidate('abbbaabb') == 'bbab'
assert candidate('bab') == 'bab'
assert candidate('a') == 'a'
# hidden tests
assert candidate('abaa') == 'abaa'
assert candidate('abaaaaab') == 'abaaaaab'
assert candidate('babab') == 'babab'
assert candidate('aaaaaab') == 'aaaaaab'
assert candidate('aaaaabbbb') == 'aaaabbb'
assert candidate('bbabbbbb') == 'bbbbbb'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('abbabaaaa') == 'babaaaa'
assert candidate('abbaaaa') == 'baaaa'
assert candidate('aaaa') == 'aaaa'
assert candidate('abbbab') == 'bbab'
assert candidate('a') == 'a'
assert candidate('bababab') == 'bababab'
assert candidate('bababbbb') == 'babbbb'
assert candidate('abb') == 'b'
assert candidate('ababbaaab') == 'abbaaab'
assert candidate('b') == 'b'
assert candidate('bbabaaaaba') == 'bbabaaaaba'
assert candidate('baababab') == 'baababab'
assert candidate('babbabbbbb') == 'bbbbbb'
assert candidate('bbaaaab') == 'bbaaaab'
assert candidate('ba') == 'ba'
assert candidate('abbbb') == 'bbb'
assert candidate('baabb') == 'bab'
assert candidate('baabbbaabb') == 'babbab'
assert candidate('baa') == 'baa'
assert candidate('aababbaba') == 'aabbaba'
assert candidate('baaab') == 'baaab'
assert candidate('ab') == 'ab'
assert candidate('b') == 'b'
assert candidate('aabbbbbabb') == 'abbbbb'
assert candidate('aaabb') == 'aab'
| 40
|
[
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbababab",
"output": "bbababab"
},
{
"input": "aabbbaa",
"output": "abbaa"
},
{
"input": "bbabaaab",
"output": "bbabaaab"
},
{
"input": "babbaaaa",
"output": "bbaaaa"
},
{
"input": "abbbaabb",
"output": "bbab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "a",
"output": "a"
}
] |
[
{
"input": "abaa",
"output": "abaa"
},
{
"input": "abaaaaab",
"output": "abaaaaab"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "aaaaaab",
"output": "aaaaaab"
},
{
"input": "aaaaabbbb",
"output": "aaaabbb"
},
{
"input": "bbabbbbb",
"output": "bbbbbb"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "abbabaaaa",
"output": "babaaaa"
},
{
"input": "abbaaaa",
"output": "baaaa"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "abbbab",
"output": "bbab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bababab",
"output": "bababab"
},
{
"input": "bababbbb",
"output": "babbbb"
},
{
"input": "abb",
"output": "b"
},
{
"input": "ababbaaab",
"output": "abbaaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbabaaaaba",
"output": "bbabaaaaba"
},
{
"input": "baababab",
"output": "baababab"
},
{
"input": "babbabbbbb",
"output": "bbbbbb"
},
{
"input": "bbaaaab",
"output": "bbaaaab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbb",
"output": "bbb"
},
{
"input": "baabb",
"output": "bab"
},
{
"input": "baabbbaabb",
"output": "babbab"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "aababbaba",
"output": "aabbaba"
},
{
"input": "baaab",
"output": "baaab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabbbbbabb",
"output": "abbbbb"
},
{
"input": "aaabb",
"output": "aab"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000080
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabbbbabbb') == 'AABBaabbB'
>>> apply_pipeline('aabbaaabab') == 'AABBAAAAB'
>>> apply_pipeline('bbbbb') == 'BBBBB'
>>> apply_pipeline('abbb') == 'ABBB'
>>> apply_pipeline('ababab') == 'AABAB'
>>> apply_pipeline('ab') == 'AB'
>>> apply_pipeline('bbabaa') == 'BABAA'
>>> apply_pipeline('aa') == 'AA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('bab', 'ab')
s = s.upper()
s = s.replace('BABB', 'aabb')
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"bab",
"ab"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BABB",
"aabb"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabbbbabbb') == 'AABBaabbB'
assert candidate('aabbaaabab') == 'AABBAAAAB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('abbb') == 'ABBB'
assert candidate('ababab') == 'AABAB'
assert candidate('ab') == 'AB'
assert candidate('bbabaa') == 'BABAA'
assert candidate('aa') == 'AA'
# hidden tests
assert candidate('babb') == 'ABB'
assert candidate('bbaaabab') == 'BBAAAAB'
assert candidate('aabbb') == 'AABBB'
assert candidate('bbbb') == 'BBBB'
assert candidate('baabbba') == 'BAABBBA'
assert candidate('a') == 'A'
assert candidate('bbbaaa') == 'BBBAAA'
assert candidate('babaabaaba') == 'ABAABAABA'
assert candidate('bababab') == 'ABAAB'
assert candidate('abaaaaaaa') == 'ABAAAAAAA'
assert candidate('aa') == 'AA'
assert candidate('bbbbabaaab') == 'BBBABAAAB'
assert candidate('bbab') == 'BAB'
assert candidate('bbabaa') == 'BABAA'
assert candidate('bbbbab') == 'BBBAB'
assert candidate('babbbbaa') == 'ABBBBAA'
assert candidate('bb') == 'BB'
assert candidate('abbbbaabba') == 'ABBBBAABBA'
assert candidate('a') == 'A'
assert candidate('aaaabb') == 'AAAABB'
assert candidate('bbb') == 'BBB'
assert candidate('aababaabb') == 'AAABAABB'
assert candidate('bb') == 'BB'
assert candidate('a') == 'A'
assert candidate('a') == 'A'
assert candidate('aababbbbab') == 'AAABBBAB'
assert candidate('babaabaa') == 'ABAABAA'
assert candidate('bb') == 'BB'
assert candidate('aaaaaabb') == 'AAAAAABB'
assert candidate('bab') == 'AB'
assert candidate('aa') == 'AA'
assert candidate('aabbababaa') == 'AABABABAA'
| 40
|
[
{
"input": "aabbbbabbb",
"output": "AABBaabbB"
},
{
"input": "aabbaaabab",
"output": "AABBAAAAB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "abbb",
"output": "ABBB"
},
{
"input": "ababab",
"output": "AABAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbabaa",
"output": "BABAA"
},
{
"input": "aa",
"output": "AA"
}
] |
[
{
"input": "babb",
"output": "ABB"
},
{
"input": "bbaaabab",
"output": "BBAAAAB"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "bbbb",
"output": "BBBB"
},
{
"input": "baabbba",
"output": "BAABBBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbaaa",
"output": "BBBAAA"
},
{
"input": "babaabaaba",
"output": "ABAABAABA"
},
{
"input": "bababab",
"output": "ABAAB"
},
{
"input": "abaaaaaaa",
"output": "ABAAAAAAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "bbbbabaaab",
"output": "BBBABAAAB"
},
{
"input": "bbab",
"output": "BAB"
},
{
"input": "bbabaa",
"output": "BABAA"
},
{
"input": "bbbbab",
"output": "BBBAB"
},
{
"input": "babbbbaa",
"output": "ABBBBAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "abbbbaabba",
"output": "ABBBBAABBA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaabb",
"output": "AAAABB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aababaabb",
"output": "AAABAABB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "a",
"output": "A"
},
{
"input": "a",
"output": "A"
},
{
"input": "aababbbbab",
"output": "AAABBBAB"
},
{
"input": "babaabaa",
"output": "ABAABAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aaaaaabb",
"output": "AAAAAABB"
},
{
"input": "bab",
"output": "AB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabbababaa",
"output": "AABABABAA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000081
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaba') == 'aaba'
>>> apply_pipeline('baaaaababa') == 'baaaaababa'
>>> apply_pipeline('babbbababb') == 'babbbababb'
>>> apply_pipeline('baabaabb') == 'baabaabb'
>>> apply_pipeline('abaaaaba') == 'abaaaaba'
>>> apply_pipeline('bbba') == 'bbba'
>>> apply_pipeline('babaaaaa') == 'babaaaaa'
"""
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('aaba') == 'aaba'
assert candidate('baaaaababa') == 'baaaaababa'
assert candidate('babbbababb') == 'babbbababb'
assert candidate('baabaabb') == 'baabaabb'
assert candidate('abaaaaba') == 'abaaaaba'
assert candidate('bbba') == 'bbba'
assert candidate('babaaaaa') == 'babaaaaa'
# hidden tests
assert candidate('bbb') == 'bbb'
assert candidate('abbba') == 'abbba'
assert candidate('aaaabbabb') == 'aaaabbabb'
assert candidate('abaabaaa') == 'abaabaaa'
assert candidate('bbaababaa') == 'bbaababaa'
assert candidate('abba') == 'abba'
assert candidate('bbbaababa') == 'bbbaababa'
assert candidate('a') == 'a'
assert candidate('aa') == 'aa'
assert candidate('babbaab') == 'babbaab'
assert candidate('bbabab') == 'bbabab'
assert candidate('baabaaab') == 'baabaaab'
assert candidate('baabbaaab') == 'baabbaaab'
assert candidate('b') == 'b'
assert candidate('aabbbaa') == 'aabbbaa'
assert candidate('abbaabb') == 'abbaabb'
assert candidate('bbbaaabb') == 'bbbaaabb'
assert candidate('a') == 'a'
assert candidate('aaabb') == 'aaabb'
assert candidate('abaaa') == 'abaaa'
assert candidate('abaaaaba') == 'abaaaaba'
assert candidate('bbabbaa') == 'bbabbaa'
assert candidate('abab') == 'abab'
assert candidate('bbbaaaba') == 'bbbaaaba'
assert candidate('aaa') == 'aaa'
assert candidate('aabaab') == 'aabaab'
assert candidate('aaabbab') == 'aaabbab'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('abaa') == 'abaa'
assert candidate('baaaabaabb') == 'baaaabaabb'
assert candidate('baaabbaabb') == 'baaabbaabb'
| 40
|
[
{
"input": "a",
"output": "a"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "baaaaababa",
"output": "baaaaababa"
},
{
"input": "babbbababb",
"output": "babbbababb"
},
{
"input": "baabaabb",
"output": "baabaabb"
},
{
"input": "abaaaaba",
"output": "abaaaaba"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "babaaaaa",
"output": "babaaaaa"
}
] |
[
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abbba",
"output": "abbba"
},
{
"input": "aaaabbabb",
"output": "aaaabbabb"
},
{
"input": "abaabaaa",
"output": "abaabaaa"
},
{
"input": "bbaababaa",
"output": "bbaababaa"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "bbbaababa",
"output": "bbbaababa"
},
{
"input": "a",
"output": "a"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "babbaab",
"output": "babbaab"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "baabaaab",
"output": "baabaaab"
},
{
"input": "baabbaaab",
"output": "baabbaaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabbbaa",
"output": "aabbbaa"
},
{
"input": "abbaabb",
"output": "abbaabb"
},
{
"input": "bbbaaabb",
"output": "bbbaaabb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "abaaaaba",
"output": "abaaaaba"
},
{
"input": "bbabbaa",
"output": "bbabbaa"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "bbbaaaba",
"output": "bbbaaaba"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "aabaab",
"output": "aabaab"
},
{
"input": "aaabbab",
"output": "aaabbab"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "baaaabaabb",
"output": "baaaabaabb"
},
{
"input": "baaabbaabb",
"output": "baaabbaabb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000082
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abab') == 'abab'
>>> apply_pipeline('bababa') == 'bababa'
>>> apply_pipeline('aaabba') == 'aaabba'
>>> apply_pipeline('bbbbaaab') == 'bbbbaaab'
>>> apply_pipeline('bbbbabb') == 'bbbbabb'
>>> apply_pipeline('bbababbba') == 'bbababbba'
>>> apply_pipeline('aa') == 'aa'
>>> apply_pipeline('a') == 'a'
"""
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('abab') == 'abab'
assert candidate('bababa') == 'bababa'
assert candidate('aaabba') == 'aaabba'
assert candidate('bbbbaaab') == 'bbbbaaab'
assert candidate('bbbbabb') == 'bbbbabb'
assert candidate('bbababbba') == 'bbababbba'
assert candidate('aa') == 'aa'
assert candidate('a') == 'a'
# hidden tests
assert candidate('ababa') == 'ababa'
assert candidate('bbabaa') == 'bbabaa'
assert candidate('abbaa') == 'abbaa'
assert candidate('bbbbababb') == 'bbbbababb'
assert candidate('abbaa') == 'abbaa'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('baaaaa') == 'baaaaa'
assert candidate('babbaba') == 'babbaba'
assert candidate('bba') == 'bba'
assert candidate('abbbabab') == 'abbbabab'
assert candidate('bbbb') == 'bbbb'
assert candidate('bbabaaba') == 'bbabaaba'
assert candidate('ababbbabab') == 'ababbbabab'
assert candidate('a') == 'a'
assert candidate('baabaabb') == 'baabaabb'
assert candidate('a') == 'a'
assert candidate('aaabb') == 'aaabb'
assert candidate('bbababaa') == 'bbababaa'
assert candidate('babbabab') == 'babbabab'
assert candidate('abaab') == 'abaab'
assert candidate('abbb') == 'abbb'
assert candidate('aabaabb') == 'aabaabb'
assert candidate('abaa') == 'abaa'
assert candidate('bbbbab') == 'bbbbab'
assert candidate('abbbaaa') == 'abbbaaa'
assert candidate('ababbaa') == 'ababbaa'
assert candidate('aababaa') == 'aababaa'
assert candidate('aab') == 'aab'
assert candidate('bbbbbab') == 'bbbbbab'
assert candidate('abaa') == 'abaa'
assert candidate('babaaba') == 'babaaba'
| 40
|
[
{
"input": "abab",
"output": "abab"
},
{
"input": "bababa",
"output": "bababa"
},
{
"input": "aaabba",
"output": "aaabba"
},
{
"input": "bbbbaaab",
"output": "bbbbaaab"
},
{
"input": "bbbbabb",
"output": "bbbbabb"
},
{
"input": "bbababbba",
"output": "bbababbba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "a",
"output": "a"
}
] |
[
{
"input": "ababa",
"output": "ababa"
},
{
"input": "bbabaa",
"output": "bbabaa"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "bbbbababb",
"output": "bbbbababb"
},
{
"input": "abbaa",
"output": "abbaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaaaa",
"output": "baaaaa"
},
{
"input": "babbaba",
"output": "babbaba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abbbabab",
"output": "abbbabab"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "bbabaaba",
"output": "bbabaaba"
},
{
"input": "ababbbabab",
"output": "ababbbabab"
},
{
"input": "a",
"output": "a"
},
{
"input": "baabaabb",
"output": "baabaabb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "bbababaa",
"output": "bbababaa"
},
{
"input": "babbabab",
"output": "babbabab"
},
{
"input": "abaab",
"output": "abaab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "aabaabb",
"output": "aabaabb"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "bbbbab",
"output": "bbbbab"
},
{
"input": "abbbaaa",
"output": "abbbaaa"
},
{
"input": "ababbaa",
"output": "ababbaa"
},
{
"input": "aababaa",
"output": "aababaa"
},
{
"input": "aab",
"output": "aab"
},
{
"input": "bbbbbab",
"output": "bbbbbab"
},
{
"input": "abaa",
"output": "abaa"
},
{
"input": "babaaba",
"output": "babaaba"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000083
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaaaab') == 'BBAAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('bababb') == 'BABABB'
>>> apply_pipeline('bbbbbaba') == 'BBBBBABA'
>>> apply_pipeline('aab') == 'AAB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('abaabbbbaa') == 'ABBBBB'
>>> apply_pipeline('abbaaaa') == 'ABBAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.upper()
s = s.replace('BAA', 'b')
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAA",
"b"
]
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaaaab') == 'BBAAB'
assert candidate('b') == 'B'
assert candidate('bababb') == 'BABABB'
assert candidate('bbbbbaba') == 'BBBBBABA'
assert candidate('aab') == 'AAB'
assert candidate('a') == 'A'
assert candidate('abaabbbbaa') == 'ABBBBB'
assert candidate('abbaaaa') == 'ABBAA'
# hidden tests
assert candidate('aab') == 'AAB'
assert candidate('bbb') == 'BBB'
assert candidate('aabaa') == 'AAB'
assert candidate('bbbbbbaaba') == 'BBBBBBBA'
assert candidate('abaabbbabb') == 'ABBBBABB'
assert candidate('aaabbbbaab') == 'AAABBBBB'
assert candidate('babbaaabaa') == 'BABBAB'
assert candidate('bba') == 'BBA'
assert candidate('aabbb') == 'AABBB'
assert candidate('aaaaabbaa') == 'AAAAABB'
assert candidate('abbaabb') == 'ABBBB'
assert candidate('babab') == 'BABAB'
assert candidate('ba') == 'BA'
assert candidate('aaaaaabbba') == 'AAAAAABBBA'
assert candidate('bbbbbaa') == 'BBBBB'
assert candidate('aa') == 'AA'
assert candidate('aabab') == 'AABAB'
assert candidate('abaabbbba') == 'ABBBBBA'
assert candidate('baab') == 'BB'
assert candidate('aaab') == 'AAAB'
assert candidate('bbb') == 'BBB'
assert candidate('abbbbbba') == 'ABBBBBBA'
assert candidate('aba') == 'ABA'
assert candidate('ab') == 'AB'
assert candidate('bbaabaabb') == 'BBBBB'
assert candidate('baabbbabb') == 'BBBBABB'
assert candidate('babaabaa') == 'BABB'
assert candidate('a') == 'A'
assert candidate('bbabbb') == 'BBABBB'
assert candidate('bbababa') == 'BBABABA'
assert candidate('bbba') == 'BBBA'
assert candidate('ab') == 'AB'
| 40
|
[
{
"input": "bbaaaab",
"output": "BBAAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bababb",
"output": "BABABB"
},
{
"input": "bbbbbaba",
"output": "BBBBBABA"
},
{
"input": "aab",
"output": "AAB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abaabbbbaa",
"output": "ABBBBB"
},
{
"input": "abbaaaa",
"output": "ABBAA"
}
] |
[
{
"input": "aab",
"output": "AAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "aabaa",
"output": "AAB"
},
{
"input": "bbbbbbaaba",
"output": "BBBBBBBA"
},
{
"input": "abaabbbabb",
"output": "ABBBBABB"
},
{
"input": "aaabbbbaab",
"output": "AAABBBBB"
},
{
"input": "babbaaabaa",
"output": "BABBAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "aaaaabbaa",
"output": "AAAAABB"
},
{
"input": "abbaabb",
"output": "ABBBB"
},
{
"input": "babab",
"output": "BABAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "aaaaaabbba",
"output": "AAAAAABBBA"
},
{
"input": "bbbbbaa",
"output": "BBBBB"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "aabab",
"output": "AABAB"
},
{
"input": "abaabbbba",
"output": "ABBBBBA"
},
{
"input": "baab",
"output": "BB"
},
{
"input": "aaab",
"output": "AAAB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "abbbbbba",
"output": "ABBBBBBA"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbaabaabb",
"output": "BBBBB"
},
{
"input": "baabbbabb",
"output": "BBBBABB"
},
{
"input": "babaabaa",
"output": "BABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbabbb",
"output": "BBABBB"
},
{
"input": "bbababa",
"output": "BBABABA"
},
{
"input": "bbba",
"output": "BBBA"
},
{
"input": "ab",
"output": "AB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000084
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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') == 'BAAABAB'
>>> apply_pipeline('aabaabba') == 'AAABAAAABABAAABAAAABBAAABA'
>>> apply_pipeline('a') == 'AAABA'
>>> apply_pipeline('bab') == 'BAAABAB'
>>> apply_pipeline('abbab') == 'AAABBAAABAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('ab') == 'AAABAB'
>>> apply_pipeline('aabab') == 'AAABAAAABABAAABAB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('A', 'aaaba')
s = s.replace('baBB', 'bb')
s = s.lower()
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"A",
"aaaba"
]
},
{
"method": "replace",
"args": [
"baBB",
"bb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bab') == 'BAAABAB'
assert candidate('aabaabba') == 'AAABAAAABABAAABAAAABBAAABA'
assert candidate('a') == 'AAABA'
assert candidate('bab') == 'BAAABAB'
assert candidate('abbab') == 'AAABBAAABAB'
assert candidate('b') == 'B'
assert candidate('ab') == 'AAABAB'
assert candidate('aabab') == 'AAABAAAABABAAABAB'
# hidden tests
assert candidate('a') == 'AAABA'
assert candidate('aaaaababbb') == 'AAABAAAABAAAABAAAABAAAABABAAABBB'
assert candidate('a') == 'AAABA'
assert candidate('ab') == 'AAABAB'
assert candidate('babbbaaab') == 'BAAABBBAAABAAAABAAAABAB'
assert candidate('bab') == 'BAAABAB'
assert candidate('abbbbaa') == 'AAABBBBAAABAAAABA'
assert candidate('bbab') == 'BBAAABAB'
assert candidate('babaaaaaa') == 'BAAABABAAABAAAABAAAABAAAABAAAABAAAABA'
assert candidate('babb') == 'BAAABB'
assert candidate('ba') == 'BAAABA'
assert candidate('bbbabb') == 'BBBAAABB'
assert candidate('bbbbbaba') == 'BBBBBAAABABAAABA'
assert candidate('aaaabaabb') == 'AAABAAAABAAAABAAAABABAAABAAAABB'
assert candidate('bbabaab') == 'BBAAABABAAABAAAABAB'
assert candidate('aaabbbbbb') == 'AAABAAAABAAAABBBBBB'
assert candidate('aabbbab') == 'AAABAAAABBBAAABAB'
assert candidate('bbaaa') == 'BBAAABAAAABAAAABA'
assert candidate('bbbba') == 'BBBBAAABA'
assert candidate('baab') == 'BAAABAAAABAB'
assert candidate('aab') == 'AAABAAAABAB'
assert candidate('a') == 'AAABA'
assert candidate('bbab') == 'BBAAABAB'
assert candidate('bbab') == 'BBAAABAB'
assert candidate('aba') == 'AAABABAAABA'
assert candidate('abbaba') == 'AAABBAAABABAAABA'
assert candidate('bbaabbbbab') == 'BBAAABAAAABBBBAAABAB'
assert candidate('abaabbb') == 'AAABABAAABAAAABBB'
assert candidate('bbba') == 'BBBAAABA'
assert candidate('bbbbbbbaaa') == 'BBBBBBBAAABAAAABAAAABA'
assert candidate('bbbbababab') == 'BBBBAAABABAAABABAAABAB'
assert candidate('bbbbbaba') == 'BBBBBAAABABAAABA'
| 40
|
[
{
"input": "bab",
"output": "BAAABAB"
},
{
"input": "aabaabba",
"output": "AAABAAAABABAAABAAAABBAAABA"
},
{
"input": "a",
"output": "AAABA"
},
{
"input": "bab",
"output": "BAAABAB"
},
{
"input": "abbab",
"output": "AAABBAAABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "ab",
"output": "AAABAB"
},
{
"input": "aabab",
"output": "AAABAAAABABAAABAB"
}
] |
[
{
"input": "a",
"output": "AAABA"
},
{
"input": "aaaaababbb",
"output": "AAABAAAABAAAABAAAABAAAABABAAABBB"
},
{
"input": "a",
"output": "AAABA"
},
{
"input": "ab",
"output": "AAABAB"
},
{
"input": "babbbaaab",
"output": "BAAABBBAAABAAAABAAAABAB"
},
{
"input": "bab",
"output": "BAAABAB"
},
{
"input": "abbbbaa",
"output": "AAABBBBAAABAAAABA"
},
{
"input": "bbab",
"output": "BBAAABAB"
},
{
"input": "babaaaaaa",
"output": "BAAABABAAABAAAABAAAABAAAABAAAABAAAABA"
},
{
"input": "babb",
"output": "BAAABB"
},
{
"input": "ba",
"output": "BAAABA"
},
{
"input": "bbbabb",
"output": "BBBAAABB"
},
{
"input": "bbbbbaba",
"output": "BBBBBAAABABAAABA"
},
{
"input": "aaaabaabb",
"output": "AAABAAAABAAAABAAAABABAAABAAAABB"
},
{
"input": "bbabaab",
"output": "BBAAABABAAABAAAABAB"
},
{
"input": "aaabbbbbb",
"output": "AAABAAAABAAAABBBBBB"
},
{
"input": "aabbbab",
"output": "AAABAAAABBBAAABAB"
},
{
"input": "bbaaa",
"output": "BBAAABAAAABAAAABA"
},
{
"input": "bbbba",
"output": "BBBBAAABA"
},
{
"input": "baab",
"output": "BAAABAAAABAB"
},
{
"input": "aab",
"output": "AAABAAAABAB"
},
{
"input": "a",
"output": "AAABA"
},
{
"input": "bbab",
"output": "BBAAABAB"
},
{
"input": "bbab",
"output": "BBAAABAB"
},
{
"input": "aba",
"output": "AAABABAAABA"
},
{
"input": "abbaba",
"output": "AAABBAAABABAAABA"
},
{
"input": "bbaabbbbab",
"output": "BBAAABAAAABBBBAAABAB"
},
{
"input": "abaabbb",
"output": "AAABABAAABAAAABBB"
},
{
"input": "bbba",
"output": "BBBAAABA"
},
{
"input": "bbbbbbbaaa",
"output": "BBBBBBBAAABAAAABAAAABA"
},
{
"input": "bbbbababab",
"output": "BBBBAAABABAAABABAAABAB"
},
{
"input": "bbbbbaba",
"output": "BBBBBAAABABAAABA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000085
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abbab') == 'ABBAB'
>>> apply_pipeline('b') == 'B'
>>> apply_pipeline('aaa') == 'AAA'
>>> apply_pipeline('baba') == 'BABA'
>>> apply_pipeline('aabbbabb') == 'AABBBABB'
>>> apply_pipeline('baabab') == 'BAABAB'
>>> apply_pipeline('babaababa') == 'BABAABABA'
>>> apply_pipeline('bbbbbaabb') == 'BBBBBAABB'
"""
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('abbab') == 'ABBAB'
assert candidate('b') == 'B'
assert candidate('aaa') == 'AAA'
assert candidate('baba') == 'BABA'
assert candidate('aabbbabb') == 'AABBBABB'
assert candidate('baabab') == 'BAABAB'
assert candidate('babaababa') == 'BABAABABA'
assert candidate('bbbbbaabb') == 'BBBBBAABB'
# hidden tests
assert candidate('abb') == 'ABB'
assert candidate('bbbaaaaba') == 'BBBAAAABA'
assert candidate('b') == 'B'
assert candidate('ba') == 'BA'
assert candidate('baabbaab') == 'BAABBAAB'
assert candidate('ab') == 'AB'
assert candidate('bbaaba') == 'BBAABA'
assert candidate('bbaaa') == 'BBAAA'
assert candidate('bbaaa') == 'BBAAA'
assert candidate('ababbbab') == 'ABABBBAB'
assert candidate('baabaab') == 'BAABAAB'
assert candidate('baabb') == 'BAABB'
assert candidate('abaaab') == 'ABAAAB'
assert candidate('ba') == 'BA'
assert candidate('bbbaa') == 'BBBAA'
assert candidate('a') == 'A'
assert candidate('baabb') == 'BAABB'
assert candidate('abababab') == 'ABABABAB'
assert candidate('b') == 'B'
assert candidate('abaa') == 'ABAA'
assert candidate('baaaabb') == 'BAAAABB'
assert candidate('aaabaabbbb') == 'AAABAABBBB'
assert candidate('babbaaa') == 'BABBAAA'
assert candidate('abaabb') == 'ABAABB'
assert candidate('bbaabbbbbb') == 'BBAABBBBBB'
assert candidate('a') == 'A'
assert candidate('babaaabbab') == 'BABAAABBAB'
assert candidate('b') == 'B'
assert candidate('bab') == 'BAB'
assert candidate('babba') == 'BABBA'
assert candidate('babab') == 'BABAB'
assert candidate('bbabb') == 'BBABB'
| 40
|
[
{
"input": "abbab",
"output": "ABBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaa",
"output": "AAA"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "aabbbabb",
"output": "AABBBABB"
},
{
"input": "baabab",
"output": "BAABAB"
},
{
"input": "babaababa",
"output": "BABAABABA"
},
{
"input": "bbbbbaabb",
"output": "BBBBBAABB"
}
] |
[
{
"input": "abb",
"output": "ABB"
},
{
"input": "bbbaaaaba",
"output": "BBBAAAABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "baabbaab",
"output": "BAABBAAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbaaba",
"output": "BBAABA"
},
{
"input": "bbaaa",
"output": "BBAAA"
},
{
"input": "bbaaa",
"output": "BBAAA"
},
{
"input": "ababbbab",
"output": "ABABBBAB"
},
{
"input": "baabaab",
"output": "BAABAAB"
},
{
"input": "baabb",
"output": "BAABB"
},
{
"input": "abaaab",
"output": "ABAAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbbaa",
"output": "BBBAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baabb",
"output": "BAABB"
},
{
"input": "abababab",
"output": "ABABABAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "abaa",
"output": "ABAA"
},
{
"input": "baaaabb",
"output": "BAAAABB"
},
{
"input": "aaabaabbbb",
"output": "AAABAABBBB"
},
{
"input": "babbaaa",
"output": "BABBAAA"
},
{
"input": "abaabb",
"output": "ABAABB"
},
{
"input": "bbaabbbbbb",
"output": "BBAABBBBBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "babaaabbab",
"output": "BABAAABBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "bab",
"output": "BAB"
},
{
"input": "babba",
"output": "BABBA"
},
{
"input": "babab",
"output": "BABAB"
},
{
"input": "bbabb",
"output": "BBABB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000086
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aababaa') == 'aabaa'
>>> apply_pipeline('abaababaa') == 'abaabaa'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('aabaaab') == 'aabaaab'
>>> apply_pipeline('aaabaaabb') == 'aaabaaabb'
>>> apply_pipeline('aaaba') == 'aaaba'
>>> apply_pipeline('babbaabba') == 'bbaabba'
>>> apply_pipeline('abbabbb') == 'abbbb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bab', 'b')
return s
|
[
{
"method": "replace",
"args": [
"bab",
"b"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababaa') == 'aabaa'
assert candidate('abaababaa') == 'abaabaa'
assert candidate('bb') == 'bb'
assert candidate('aabaaab') == 'aabaaab'
assert candidate('aaabaaabb') == 'aaabaaabb'
assert candidate('aaaba') == 'aaaba'
assert candidate('babbaabba') == 'bbaabba'
assert candidate('abbabbb') == 'abbbb'
# hidden tests
assert candidate('ba') == 'ba'
assert candidate('abaababa') == 'abaaba'
assert candidate('aaaaaabbab') == 'aaaaaabb'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('bbbba') == 'bbbba'
assert candidate('aa') == 'aa'
assert candidate('aabaaaaa') == 'aabaaaaa'
assert candidate('babbaababb') == 'bbaabb'
assert candidate('baabbb') == 'baabbb'
assert candidate('bbaababbab') == 'bbaabb'
assert candidate('abbbbab') == 'abbbb'
assert candidate('abbaab') == 'abbaab'
assert candidate('aaaabaaa') == 'aaaabaaa'
assert candidate('baba') == 'ba'
assert candidate('aabb') == 'aabb'
assert candidate('bbaaaabbaa') == 'bbaaaabbaa'
assert candidate('aabaabaaba') == 'aabaabaaba'
assert candidate('aabbabbaaa') == 'aabbbaaa'
assert candidate('abaaaaa') == 'abaaaaa'
assert candidate('ba') == 'ba'
assert candidate('abbbbaba') == 'abbbba'
assert candidate('baaaabbbab') == 'baaaabbb'
assert candidate('bab') == 'b'
assert candidate('babbababaa') == 'bbabaa'
assert candidate('a') == 'a'
assert candidate('bba') == 'bba'
assert candidate('b') == 'b'
assert candidate('bbaabaa') == 'bbaabaa'
assert candidate('bbbbab') == 'bbbb'
assert candidate('abbabbaaab') == 'abbbaaab'
assert candidate('bbababbaba') == 'bbabba'
| 40
|
[
{
"input": "aababaa",
"output": "aabaa"
},
{
"input": "abaababaa",
"output": "abaabaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aabaaab",
"output": "aabaaab"
},
{
"input": "aaabaaabb",
"output": "aaabaaabb"
},
{
"input": "aaaba",
"output": "aaaba"
},
{
"input": "babbaabba",
"output": "bbaabba"
},
{
"input": "abbabbb",
"output": "abbbb"
}
] |
[
{
"input": "ba",
"output": "ba"
},
{
"input": "abaababa",
"output": "abaaba"
},
{
"input": "aaaaaabbab",
"output": "aaaaaabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aabaaaaa",
"output": "aabaaaaa"
},
{
"input": "babbaababb",
"output": "bbaabb"
},
{
"input": "baabbb",
"output": "baabbb"
},
{
"input": "bbaababbab",
"output": "bbaabb"
},
{
"input": "abbbbab",
"output": "abbbb"
},
{
"input": "abbaab",
"output": "abbaab"
},
{
"input": "aaaabaaa",
"output": "aaaabaaa"
},
{
"input": "baba",
"output": "ba"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "bbaaaabbaa",
"output": "bbaaaabbaa"
},
{
"input": "aabaabaaba",
"output": "aabaabaaba"
},
{
"input": "aabbabbaaa",
"output": "aabbbaaa"
},
{
"input": "abaaaaa",
"output": "abaaaaa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "abbbbaba",
"output": "abbbba"
},
{
"input": "baaaabbbab",
"output": "baaaabbb"
},
{
"input": "bab",
"output": "b"
},
{
"input": "babbababaa",
"output": "bbabaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbaabaa",
"output": "bbaabaa"
},
{
"input": "bbbbab",
"output": "bbbb"
},
{
"input": "abbabbaaab",
"output": "abbbaaab"
},
{
"input": "bbababbaba",
"output": "bbabba"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000087
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaabb') == 'aaabb'
>>> apply_pipeline('bb') == 'bb'
>>> apply_pipeline('bbbbaaab') == 'bbbbaaab'
>>> apply_pipeline('baaa') == 'baaa'
>>> apply_pipeline('babab') == 'babab'
>>> apply_pipeline('abbabababa') == 'abbabababa'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('aaaba') == 'aaaba'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.lower()
s = s.replace('abaa', 'aba')
s = s.lower()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"abaa",
"aba"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabb') == 'aaabb'
assert candidate('bb') == 'bb'
assert candidate('bbbbaaab') == 'bbbbaaab'
assert candidate('baaa') == 'baaa'
assert candidate('babab') == 'babab'
assert candidate('abbabababa') == 'abbabababa'
assert candidate('b') == 'b'
assert candidate('aaaba') == 'aaaba'
# hidden tests
assert candidate('aabbabba') == 'aabbabba'
assert candidate('aababaa') == 'aababa'
assert candidate('bbababaaba') == 'bbabababa'
assert candidate('aa') == 'aa'
assert candidate('bb') == 'bb'
assert candidate('aaaaaaabbb') == 'aaaaaaabbb'
assert candidate('abaabbab') == 'ababbab'
assert candidate('bab') == 'bab'
assert candidate('ab') == 'ab'
assert candidate('bba') == 'bba'
assert candidate('abb') == 'abb'
assert candidate('bbaa') == 'bbaa'
assert candidate('aabaa') == 'aaba'
assert candidate('abbabbab') == 'abbabbab'
assert candidate('bab') == 'bab'
assert candidate('abaabbbbab') == 'ababbbbab'
assert candidate('ababb') == 'ababb'
assert candidate('aaabaaaa') == 'aaabaaa'
assert candidate('baaa') == 'baaa'
assert candidate('aaaa') == 'aaaa'
assert candidate('babaabbb') == 'bababbb'
assert candidate('baaaaaaaa') == 'baaaaaaaa'
assert candidate('b') == 'b'
assert candidate('bbab') == 'bbab'
assert candidate('aaba') == 'aaba'
assert candidate('bbabaaaab') == 'bbabaaab'
assert candidate('aabaaabab') == 'aabaabab'
assert candidate('aa') == 'aa'
assert candidate('bbaaabbb') == 'bbaaabbb'
assert candidate('aaaa') == 'aaaa'
assert candidate('abbbabbb') == 'abbbabbb'
assert candidate('abbaa') == 'abbaa'
| 40
|
[
{
"input": "aaabb",
"output": "aaabb"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "bbbbaaab",
"output": "bbbbaaab"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "babab",
"output": "babab"
},
{
"input": "abbabababa",
"output": "abbabababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaaba",
"output": "aaaba"
}
] |
[
{
"input": "aabbabba",
"output": "aabbabba"
},
{
"input": "aababaa",
"output": "aababa"
},
{
"input": "bbababaaba",
"output": "bbabababa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaaaaaabbb",
"output": "aaaaaaabbb"
},
{
"input": "abaabbab",
"output": "ababbab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "aabaa",
"output": "aaba"
},
{
"input": "abbabbab",
"output": "abbabbab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abaabbbbab",
"output": "ababbbbab"
},
{
"input": "ababb",
"output": "ababb"
},
{
"input": "aaabaaaa",
"output": "aaabaaa"
},
{
"input": "baaa",
"output": "baaa"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "babaabbb",
"output": "bababbb"
},
{
"input": "baaaaaaaa",
"output": "baaaaaaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "bbabaaaab",
"output": "bbabaaab"
},
{
"input": "aabaaabab",
"output": "aabaabab"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbaaabbb",
"output": "bbaaabbb"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "abbbabbb",
"output": "abbbabbb"
},
{
"input": "abbaa",
"output": "abbaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 5,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000088
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aabbb') == 'AABBB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('bbb') == 'BBB'
>>> apply_pipeline('baaaaaba') == 'ABBBAAABA'
>>> apply_pipeline('bbabaaa') == 'BBAABBBA'
>>> apply_pipeline('aabbaabb') == 'AABBAABB'
>>> apply_pipeline('bbaabbab') == 'BBAABBAB'
>>> apply_pipeline('bbb') == 'BBB'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BAAA', 'abbba')
s = s.upper()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BAAA",
"abbba"
]
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aabbb') == 'AABBB'
assert candidate('a') == 'A'
assert candidate('bbb') == 'BBB'
assert candidate('baaaaaba') == 'ABBBAAABA'
assert candidate('bbabaaa') == 'BBAABBBA'
assert candidate('aabbaabb') == 'AABBAABB'
assert candidate('bbaabbab') == 'BBAABBAB'
assert candidate('bbb') == 'BBB'
# hidden tests
assert candidate('babaabb') == 'BABAABB'
assert candidate('abaabababb') == 'ABAABABABB'
assert candidate('bb') == 'BB'
assert candidate('bbaaaaaa') == 'BABBBAAAA'
assert candidate('bb') == 'BB'
assert candidate('aabbbabb') == 'AABBBABB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('abbaaaaaa') == 'ABABBBAAAA'
assert candidate('abbbabba') == 'ABBBABBA'
assert candidate('bbaab') == 'BBAAB'
assert candidate('bbbaabb') == 'BBBAABB'
assert candidate('ababbbbbb') == 'ABABBBBBB'
assert candidate('baba') == 'BABA'
assert candidate('abaab') == 'ABAAB'
assert candidate('ba') == 'BA'
assert candidate('bbbbbbbba') == 'BBBBBBBBA'
assert candidate('aaababbaba') == 'AAABABBABA'
assert candidate('bb') == 'BB'
assert candidate('babbbbaabb') == 'BABBBBAABB'
assert candidate('bbab') == 'BBAB'
assert candidate('bbbab') == 'BBBAB'
assert candidate('b') == 'B'
assert candidate('baabaabb') == 'BAABAABB'
assert candidate('bbabb') == 'BBABB'
assert candidate('abbabb') == 'ABBABB'
assert candidate('bbbbb') == 'BBBBB'
assert candidate('baabbaa') == 'BAABBAA'
assert candidate('abaaba') == 'ABAABA'
assert candidate('baabbbba') == 'BAABBBBA'
assert candidate('babbaabba') == 'BABBAABBA'
assert candidate('bbb') == 'BBB'
assert candidate('ababa') == 'ABABA'
| 40
|
[
{
"input": "aabbb",
"output": "AABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "baaaaaba",
"output": "ABBBAAABA"
},
{
"input": "bbabaaa",
"output": "BBAABBBA"
},
{
"input": "aabbaabb",
"output": "AABBAABB"
},
{
"input": "bbaabbab",
"output": "BBAABBAB"
},
{
"input": "bbb",
"output": "BBB"
}
] |
[
{
"input": "babaabb",
"output": "BABAABB"
},
{
"input": "abaabababb",
"output": "ABAABABABB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "bbaaaaaa",
"output": "BABBBAAAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabbbabb",
"output": "AABBBABB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "abbaaaaaa",
"output": "ABABBBAAAA"
},
{
"input": "abbbabba",
"output": "ABBBABBA"
},
{
"input": "bbaab",
"output": "BBAAB"
},
{
"input": "bbbaabb",
"output": "BBBAABB"
},
{
"input": "ababbbbbb",
"output": "ABABBBBBB"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "abaab",
"output": "ABAAB"
},
{
"input": "ba",
"output": "BA"
},
{
"input": "bbbbbbbba",
"output": "BBBBBBBBA"
},
{
"input": "aaababbaba",
"output": "AAABABBABA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "babbbbaabb",
"output": "BABBBBAABB"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "bbbab",
"output": "BBBAB"
},
{
"input": "b",
"output": "B"
},
{
"input": "baabaabb",
"output": "BAABAABB"
},
{
"input": "bbabb",
"output": "BBABB"
},
{
"input": "abbabb",
"output": "ABBABB"
},
{
"input": "bbbbb",
"output": "BBBBB"
},
{
"input": "baabbaa",
"output": "BAABBAA"
},
{
"input": "abaaba",
"output": "ABAABA"
},
{
"input": "baabbbba",
"output": "BAABBBBA"
},
{
"input": "babbaabba",
"output": "BABBAABBA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "ababa",
"output": "ABABA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000089
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aababb') == 'aabbabbb'
>>> apply_pipeline('ab') == 'ab'
>>> apply_pipeline('aabaabab') == 'aabbababbabb'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('babba') == 'bbabbbbab'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('babaaabaaa') == 'bbabbbabaabbabaa'
>>> apply_pipeline('abaab') == 'abbabab'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.replace('BA', 'bbab')
s = s.lower()
s = s.lower()
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"BA",
"bbab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aababb') == 'aabbabbb'
assert candidate('ab') == 'ab'
assert candidate('aabaabab') == 'aabbababbabb'
assert candidate('b') == 'b'
assert candidate('babba') == 'bbabbbbab'
assert candidate('abbb') == 'abbb'
assert candidate('babaaabaaa') == 'bbabbbabaabbabaa'
assert candidate('abaab') == 'abbabab'
# hidden tests
assert candidate('ab') == 'ab'
assert candidate('bbbaab') == 'bbbbabab'
assert candidate('ba') == 'bbab'
assert candidate('abbaaa') == 'abbbabaa'
assert candidate('b') == 'b'
assert candidate('aabaaa') == 'aabbabaa'
assert candidate('bbaabbabbb') == 'bbbababbbabbbb'
assert candidate('bbabbbbabb') == 'bbbabbbbbbabbb'
assert candidate('abaabb') == 'abbababb'
assert candidate('abbba') == 'abbbbab'
assert candidate('bbaabbaa') == 'bbbababbbaba'
assert candidate('ababa') == 'abbabbbab'
assert candidate('bb') == 'bb'
assert candidate('baabbb') == 'bbababbb'
assert candidate('abbbab') == 'abbbbabb'
assert candidate('ababb') == 'abbabbb'
assert candidate('a') == 'a'
assert candidate('aabaab') == 'aabbabab'
assert candidate('babbbabab') == 'bbabbbbbabbbabb'
assert candidate('ba') == 'bbab'
assert candidate('aabba') == 'aabbbab'
assert candidate('aabababb') == 'aabbabbbabbb'
assert candidate('baabbbaabb') == 'bbababbbbababb'
assert candidate('ba') == 'bbab'
assert candidate('aabbaa') == 'aabbbaba'
assert candidate('baaabbba') == 'bbabaabbbbab'
assert candidate('bbbbbabbb') == 'bbbbbbabbbb'
assert candidate('b') == 'b'
assert candidate('baaaaab') == 'bbabaaaab'
assert candidate('abaaaababa') == 'abbabaaabbabbbab'
assert candidate('baabbb') == 'bbababbb'
assert candidate('a') == 'a'
| 40
|
[
{
"input": "aababb",
"output": "aabbabbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "aabaabab",
"output": "aabbababbabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "babba",
"output": "bbabbbbab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "babaaabaaa",
"output": "bbabbbabaabbabaa"
},
{
"input": "abaab",
"output": "abbabab"
}
] |
[
{
"input": "ab",
"output": "ab"
},
{
"input": "bbbaab",
"output": "bbbbabab"
},
{
"input": "ba",
"output": "bbab"
},
{
"input": "abbaaa",
"output": "abbbabaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aabaaa",
"output": "aabbabaa"
},
{
"input": "bbaabbabbb",
"output": "bbbababbbabbbb"
},
{
"input": "bbabbbbabb",
"output": "bbbabbbbbbabbb"
},
{
"input": "abaabb",
"output": "abbababb"
},
{
"input": "abbba",
"output": "abbbbab"
},
{
"input": "bbaabbaa",
"output": "bbbababbbaba"
},
{
"input": "ababa",
"output": "abbabbbab"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "baabbb",
"output": "bbababbb"
},
{
"input": "abbbab",
"output": "abbbbabb"
},
{
"input": "ababb",
"output": "abbabbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabaab",
"output": "aabbabab"
},
{
"input": "babbbabab",
"output": "bbabbbbbabbbabb"
},
{
"input": "ba",
"output": "bbab"
},
{
"input": "aabba",
"output": "aabbbab"
},
{
"input": "aabababb",
"output": "aabbabbbabbb"
},
{
"input": "baabbbaabb",
"output": "bbababbbbababb"
},
{
"input": "ba",
"output": "bbab"
},
{
"input": "aabbaa",
"output": "aabbbaba"
},
{
"input": "baaabbba",
"output": "bbabaabbbbab"
},
{
"input": "bbbbbabbb",
"output": "bbbbbbabbbb"
},
{
"input": "b",
"output": "b"
},
{
"input": "baaaaab",
"output": "bbabaaaab"
},
{
"input": "abaaaababa",
"output": "abbabaaabbabbbab"
},
{
"input": "baabbb",
"output": "bbababbb"
},
{
"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/000090
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('babaa') == 'baab'
>>> apply_pipeline('bbaaaabba') == 'babaabba'
>>> apply_pipeline('bbb') == 'bbb'
>>> apply_pipeline('bbab') == 'bbab'
>>> apply_pipeline('aaaaba') == 'aaaaba'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('abaaaabbb') == 'aabaabbb'
>>> apply_pipeline('baab') == 'abb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('baa', 'ab')
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"baa",
"ab"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('babaa') == 'baab'
assert candidate('bbaaaabba') == 'babaabba'
assert candidate('bbb') == 'bbb'
assert candidate('bbab') == 'bbab'
assert candidate('aaaaba') == 'aaaaba'
assert candidate('a') == 'a'
assert candidate('abaaaabbb') == 'aabaabbb'
assert candidate('baab') == 'abb'
# hidden tests
assert candidate('abaaabaa') == 'aabaab'
assert candidate('ababbababa') == 'ababbababa'
assert candidate('baa') == 'ab'
assert candidate('abaabaab') == 'aababb'
assert candidate('babbabb') == 'babbabb'
assert candidate('abbb') == 'abbb'
assert candidate('bababa') == 'bababa'
assert candidate('baabb') == 'abbb'
assert candidate('aaaaaab') == 'aaaaaab'
assert candidate('aaa') == 'aaa'
assert candidate('aabaabaab') == 'aaababb'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('abbbb') == 'abbbb'
assert candidate('ababaabb') == 'abaabbb'
assert candidate('bbababab') == 'bbababab'
assert candidate('aaaa') == 'aaaa'
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('abbbabbaba') == 'abbbabbaba'
assert candidate('ab') == 'ab'
assert candidate('bbaa') == 'bab'
assert candidate('baabbaa') == 'abbab'
assert candidate('abababbb') == 'abababbb'
assert candidate('ababaabab') == 'abaabbab'
assert candidate('baaaaaabab') == 'abaaaabab'
assert candidate('bbaba') == 'bbaba'
assert candidate('bbbb') == 'bbbb'
assert candidate('abaaaaaa') == 'aabaaaa'
assert candidate('bbbabbb') == 'bbbabbb'
assert candidate('abaa') == 'aab'
assert candidate('ababaabb') == 'abaabbb'
| 40
|
[
{
"input": "babaa",
"output": "baab"
},
{
"input": "bbaaaabba",
"output": "babaabba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "aaaaba",
"output": "aaaaba"
},
{
"input": "a",
"output": "a"
},
{
"input": "abaaaabbb",
"output": "aabaabbb"
},
{
"input": "baab",
"output": "abb"
}
] |
[
{
"input": "abaaabaa",
"output": "aabaab"
},
{
"input": "ababbababa",
"output": "ababbababa"
},
{
"input": "baa",
"output": "ab"
},
{
"input": "abaabaab",
"output": "aababb"
},
{
"input": "babbabb",
"output": "babbabb"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "bababa",
"output": "bababa"
},
{
"input": "baabb",
"output": "abbb"
},
{
"input": "aaaaaab",
"output": "aaaaaab"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "aabaabaab",
"output": "aaababb"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbb",
"output": "abbbb"
},
{
"input": "ababaabb",
"output": "abaabbb"
},
{
"input": "bbababab",
"output": "bbababab"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbabbaba",
"output": "abbbabbaba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbaa",
"output": "bab"
},
{
"input": "baabbaa",
"output": "abbab"
},
{
"input": "abababbb",
"output": "abababbb"
},
{
"input": "ababaabab",
"output": "abaabbab"
},
{
"input": "baaaaaabab",
"output": "abaaaabab"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "abaaaaaa",
"output": "aabaaaa"
},
{
"input": "bbbabbb",
"output": "bbbabbb"
},
{
"input": "abaa",
"output": "aab"
},
{
"input": "ababaabb",
"output": "abaabbb"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000091
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abababa') == 'abababa'
>>> apply_pipeline('ba') == 'ba'
>>> apply_pipeline('bba') == 'bba'
>>> apply_pipeline('aabbb') == 'aabbb'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('ababaaa') == 'ababaaa'
>>> apply_pipeline('aabb') == 'aabb'
>>> 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('abababa') == 'abababa'
assert candidate('ba') == 'ba'
assert candidate('bba') == 'bba'
assert candidate('aabbb') == 'aabbb'
assert candidate('a') == 'a'
assert candidate('ababaaa') == 'ababaaa'
assert candidate('aabb') == 'aabb'
assert candidate('b') == 'b'
# hidden tests
assert candidate('bbbb') == 'bbbb'
assert candidate('ab') == 'ab'
assert candidate('a') == 'a'
assert candidate('bbabbbbba') == 'bbabbbbba'
assert candidate('b') == 'b'
assert candidate('bb') == 'bb'
assert candidate('aaa') == 'aaa'
assert candidate('bb') == 'bb'
assert candidate('aaab') == 'aaab'
assert candidate('bbbaaabb') == 'bbbaaabb'
assert candidate('bbbabbba') == 'bbbabbba'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('aabba') == 'aabba'
assert candidate('a') == 'a'
assert candidate('bbbaaaabba') == 'bbbaaaabba'
assert candidate('aa') == 'aa'
assert candidate('bbbaaba') == 'bbbaaba'
assert candidate('b') == 'b'
assert candidate('babbab') == 'babbab'
assert candidate('bbaaab') == 'bbaaab'
assert candidate('bbab') == 'bbab'
assert candidate('a') == 'a'
assert candidate('aaabbab') == 'aaabbab'
assert candidate('bbabaaaa') == 'bbabaaaa'
assert candidate('aa') == 'aa'
assert candidate('bba') == 'bba'
assert candidate('ab') == 'ab'
assert candidate('bbabb') == 'bbabb'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
| 40
|
[
{
"input": "abababa",
"output": "abababa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "aabbb",
"output": "aabbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "ababaaa",
"output": "ababaaa"
},
{
"input": "aabb",
"output": "aabb"
},
{
"input": "b",
"output": "b"
}
] |
[
{
"input": "bbbb",
"output": "bbbb"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabbbbba",
"output": "bbabbbbba"
},
{
"input": "b",
"output": "b"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aaab",
"output": "aaab"
},
{
"input": "bbbaaabb",
"output": "bbbaaabb"
},
{
"input": "bbbabbba",
"output": "bbbabbba"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbaaaabba",
"output": "bbbaaaabba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bbbaaba",
"output": "bbbaaba"
},
{
"input": "b",
"output": "b"
},
{
"input": "babbab",
"output": "babbab"
},
{
"input": "bbaaab",
"output": "bbaaab"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "a",
"output": "a"
},
{
"input": "aaabbab",
"output": "aaabbab"
},
{
"input": "bbabaaaa",
"output": "bbabaaaa"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "bbabb",
"output": "bbabb"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 1,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000092
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('abba') == 'ABBA'
>>> apply_pipeline('aaababb') == 'AAABBBB'
>>> apply_pipeline('bbbbaaba') == 'BBBBBAABB'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('babaabbb') == 'BABAABBBB'
>>> apply_pipeline('aba') == 'ABA'
>>> apply_pipeline('babbbbabba') == 'BABBBBBABBA'
>>> apply_pipeline('a') == 'A'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bbb', 'bbbb')
s = s.upper()
s = s.replace('AABA', 'aabb')
s = s.upper()
return s
|
[
{
"method": "replace",
"args": [
"bbb",
"bbbb"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AABA",
"aabb"
]
},
{
"method": "upper",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abba') == 'ABBA'
assert candidate('aaababb') == 'AAABBBB'
assert candidate('bbbbaaba') == 'BBBBBAABB'
assert candidate('a') == 'A'
assert candidate('babaabbb') == 'BABAABBBB'
assert candidate('aba') == 'ABA'
assert candidate('babbbbabba') == 'BABBBBBABBA'
assert candidate('a') == 'A'
# hidden tests
assert candidate('b') == 'B'
assert candidate('baab') == 'BAAB'
assert candidate('abaaababa') == 'ABAAABBBA'
assert candidate('aabbabaa') == 'AABBABAA'
assert candidate('bababaa') == 'BABABAA'
assert candidate('bbbaabbb') == 'BBBBAABBBB'
assert candidate('b') == 'B'
assert candidate('b') == 'B'
assert candidate('baaaa') == 'BAAAA'
assert candidate('b') == 'B'
assert candidate('bbbababbb') == 'BBBBABABBBB'
assert candidate('bbabbaaaa') == 'BBABBAAAA'
assert candidate('babbbbbaaa') == 'BABBBBBBAAA'
assert candidate('bbaa') == 'BBAA'
assert candidate('bb') == 'BB'
assert candidate('abaaabbb') == 'ABAAABBBB'
assert candidate('aababbabaa') == 'AABBBBABAA'
assert candidate('bb') == 'BB'
assert candidate('baaa') == 'BAAA'
assert candidate('abaaabaabb') == 'ABAAABBABB'
assert candidate('abbbbbabab') == 'ABBBBBBABAB'
assert candidate('ab') == 'AB'
assert candidate('baa') == 'BAA'
assert candidate('abaabababb') == 'ABAABBBABB'
assert candidate('bb') == 'BB'
assert candidate('aabbaba') == 'AABBABA'
assert candidate('b') == 'B'
assert candidate('aabbabab') == 'AABBABAB'
assert candidate('bbbbabaaaa') == 'BBBBBABAAAA'
assert candidate('abab') == 'ABAB'
assert candidate('bb') == 'BB'
assert candidate('baabbbbbab') == 'BAABBBBBBAB'
| 40
|
[
{
"input": "abba",
"output": "ABBA"
},
{
"input": "aaababb",
"output": "AAABBBB"
},
{
"input": "bbbbaaba",
"output": "BBBBBAABB"
},
{
"input": "a",
"output": "A"
},
{
"input": "babaabbb",
"output": "BABAABBBB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "babbbbabba",
"output": "BABBBBBABBA"
},
{
"input": "a",
"output": "A"
}
] |
[
{
"input": "b",
"output": "B"
},
{
"input": "baab",
"output": "BAAB"
},
{
"input": "abaaababa",
"output": "ABAAABBBA"
},
{
"input": "aabbabaa",
"output": "AABBABAA"
},
{
"input": "bababaa",
"output": "BABABAA"
},
{
"input": "bbbaabbb",
"output": "BBBBAABBBB"
},
{
"input": "b",
"output": "B"
},
{
"input": "b",
"output": "B"
},
{
"input": "baaaa",
"output": "BAAAA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbbababbb",
"output": "BBBBABABBBB"
},
{
"input": "bbabbaaaa",
"output": "BBABBAAAA"
},
{
"input": "babbbbbaaa",
"output": "BABBBBBBAAA"
},
{
"input": "bbaa",
"output": "BBAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "abaaabbb",
"output": "ABAAABBBB"
},
{
"input": "aababbabaa",
"output": "AABBBBABAA"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baaa",
"output": "BAAA"
},
{
"input": "abaaabaabb",
"output": "ABAAABBABB"
},
{
"input": "abbbbbabab",
"output": "ABBBBBBABAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "baa",
"output": "BAA"
},
{
"input": "abaabababb",
"output": "ABAABBBABB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "aabbaba",
"output": "AABBABA"
},
{
"input": "b",
"output": "B"
},
{
"input": "aabbabab",
"output": "AABBABAB"
},
{
"input": "bbbbabaaaa",
"output": "BBBBBABAAAA"
},
{
"input": "abab",
"output": "ABAB"
},
{
"input": "bb",
"output": "BB"
},
{
"input": "baabbbbbab",
"output": "BAABBBBBBAB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000093
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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') == 'BBBbaaabbaaab'
>>> apply_pipeline('aa') == 'baaabbaaab'
>>> apply_pipeline('bbbaba') == 'BBBBbaaabBbaaab'
>>> apply_pipeline('bbbbbaabaa') == 'BBBBBBBbaaabbaaabBbaaabbaaab'
>>> apply_pipeline('ababababa') == 'baaabBbaaabBbaaabBbaaabBbaaab'
>>> apply_pipeline('ababababb') == 'baaabBbaaabBbaaabBbaaabBBB'
>>> apply_pipeline('ab') == 'baaabB'
>>> apply_pipeline('bbba') == 'BBBBbaaab'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('bb', 'bbb')
s = s.lower()
s = s.upper()
s = s.replace('A', 'baaab')
return s
|
[
{
"method": "replace",
"args": [
"bb",
"bbb"
]
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"A",
"baaab"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('bbaa') == 'BBBbaaabbaaab'
assert candidate('aa') == 'baaabbaaab'
assert candidate('bbbaba') == 'BBBBbaaabBbaaab'
assert candidate('bbbbbaabaa') == 'BBBBBBBbaaabbaaabBbaaabbaaab'
assert candidate('ababababa') == 'baaabBbaaabBbaaabBbaaabBbaaab'
assert candidate('ababababb') == 'baaabBbaaabBbaaabBbaaabBBB'
assert candidate('ab') == 'baaabB'
assert candidate('bbba') == 'BBBBbaaab'
# hidden tests
assert candidate('bbbbabaaa') == 'BBBBBBbaaabBbaaabbaaabbaaab'
assert candidate('bbb') == 'BBBB'
assert candidate('aaaaaba') == 'baaabbaaabbaaabbaaabbaaabBbaaab'
assert candidate('baabbbbba') == 'BbaaabbaaabBBBBBBBbaaab'
assert candidate('aa') == 'baaabbaaab'
assert candidate('bb') == 'BBB'
assert candidate('aaaaaabb') == 'baaabbaaabbaaabbaaabbaaabbaaabBBB'
assert candidate('bbbaaaaaaa') == 'BBBBbaaabbaaabbaaabbaaabbaaabbaaabbaaab'
assert candidate('ba') == 'Bbaaab'
assert candidate('abaaabba') == 'baaabBbaaabbaaabbaaabBBBbaaab'
assert candidate('ba') == 'Bbaaab'
assert candidate('b') == 'B'
assert candidate('abab') == 'baaabBbaaabB'
assert candidate('ababaa') == 'baaabBbaaabBbaaabbaaab'
assert candidate('b') == 'B'
assert candidate('aaaa') == 'baaabbaaabbaaabbaaab'
assert candidate('abaabaaa') == 'baaabBbaaabbaaabBbaaabbaaabbaaab'
assert candidate('aaabaaaab') == 'baaabbaaabbaaabBbaaabbaaabbaaabbaaabB'
assert candidate('a') == 'baaab'
assert candidate('bbaab') == 'BBBbaaabbaaabB'
assert candidate('b') == 'B'
assert candidate('abaabbaa') == 'baaabBbaaabbaaabBBBbaaabbaaab'
assert candidate('abaaaba') == 'baaabBbaaabbaaabbaaabBbaaab'
assert candidate('ba') == 'Bbaaab'
assert candidate('abaabbb') == 'baaabBbaaabbaaabBBBB'
assert candidate('ba') == 'Bbaaab'
assert candidate('b') == 'B'
assert candidate('ba') == 'Bbaaab'
assert candidate('aaab') == 'baaabbaaabbaaabB'
assert candidate('aaababba') == 'baaabbaaabbaaabBbaaabBBBbaaab'
assert candidate('bbbb') == 'BBBBBB'
assert candidate('aaab') == 'baaabbaaabbaaabB'
| 40
|
[
{
"input": "bbaa",
"output": "BBBbaaabbaaab"
},
{
"input": "aa",
"output": "baaabbaaab"
},
{
"input": "bbbaba",
"output": "BBBBbaaabBbaaab"
},
{
"input": "bbbbbaabaa",
"output": "BBBBBBBbaaabbaaabBbaaabbaaab"
},
{
"input": "ababababa",
"output": "baaabBbaaabBbaaabBbaaabBbaaab"
},
{
"input": "ababababb",
"output": "baaabBbaaabBbaaabBbaaabBBB"
},
{
"input": "ab",
"output": "baaabB"
},
{
"input": "bbba",
"output": "BBBBbaaab"
}
] |
[
{
"input": "bbbbabaaa",
"output": "BBBBBBbaaabBbaaabbaaabbaaab"
},
{
"input": "bbb",
"output": "BBBB"
},
{
"input": "aaaaaba",
"output": "baaabbaaabbaaabbaaabbaaabBbaaab"
},
{
"input": "baabbbbba",
"output": "BbaaabbaaabBBBBBBBbaaab"
},
{
"input": "aa",
"output": "baaabbaaab"
},
{
"input": "bb",
"output": "BBB"
},
{
"input": "aaaaaabb",
"output": "baaabbaaabbaaabbaaabbaaabbaaabBBB"
},
{
"input": "bbbaaaaaaa",
"output": "BBBBbaaabbaaabbaaabbaaabbaaabbaaabbaaab"
},
{
"input": "ba",
"output": "Bbaaab"
},
{
"input": "abaaabba",
"output": "baaabBbaaabbaaabbaaabBBBbaaab"
},
{
"input": "ba",
"output": "Bbaaab"
},
{
"input": "b",
"output": "B"
},
{
"input": "abab",
"output": "baaabBbaaabB"
},
{
"input": "ababaa",
"output": "baaabBbaaabBbaaabbaaab"
},
{
"input": "b",
"output": "B"
},
{
"input": "aaaa",
"output": "baaabbaaabbaaabbaaab"
},
{
"input": "abaabaaa",
"output": "baaabBbaaabbaaabBbaaabbaaabbaaab"
},
{
"input": "aaabaaaab",
"output": "baaabbaaabbaaabBbaaabbaaabbaaabbaaabB"
},
{
"input": "a",
"output": "baaab"
},
{
"input": "bbaab",
"output": "BBBbaaabbaaabB"
},
{
"input": "b",
"output": "B"
},
{
"input": "abaabbaa",
"output": "baaabBbaaabbaaabBBBbaaabbaaab"
},
{
"input": "abaaaba",
"output": "baaabBbaaabbaaabbaaabBbaaab"
},
{
"input": "ba",
"output": "Bbaaab"
},
{
"input": "abaabbb",
"output": "baaabBbaaabbaaabBBBB"
},
{
"input": "ba",
"output": "Bbaaab"
},
{
"input": "b",
"output": "B"
},
{
"input": "ba",
"output": "Bbaaab"
},
{
"input": "aaab",
"output": "baaabbaaabbaaabB"
},
{
"input": "aaababba",
"output": "baaabbaaabbaaabBbaaabBBBbaaab"
},
{
"input": "bbbb",
"output": "BBBBBB"
},
{
"input": "aaab",
"output": "baaabbaaabbaaabB"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000094
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bab') == 'bab'
>>> apply_pipeline('abbaaa') == 'abbaaa'
>>> apply_pipeline('abbbabab') == 'abbbabab'
>>> apply_pipeline('baaabb') == 'baaabb'
>>> apply_pipeline('baabb') == 'baabb'
>>> apply_pipeline('aabaab') == 'aabaab'
>>> apply_pipeline('bb') == 'bb'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.lower()
s = s.replace('baaaa', 'bb')
s = s.lower()
return s
|
[
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"baaaa",
"bb"
]
},
{
"method": "lower",
"args": []
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('abaa') == 'abaa'
assert candidate('bab') == 'bab'
assert candidate('abbaaa') == 'abbaaa'
assert candidate('abbbabab') == 'abbbabab'
assert candidate('baaabb') == 'baaabb'
assert candidate('baabb') == 'baabb'
assert candidate('aabaab') == 'aabaab'
assert candidate('bb') == 'bb'
# hidden tests
assert candidate('aaabaa') == 'aaabaa'
assert candidate('baaaaab') == 'bbab'
assert candidate('a') == 'a'
assert candidate('bbbaaaa') == 'bbbb'
assert candidate('ababab') == 'ababab'
assert candidate('bbbbabab') == 'bbbbabab'
assert candidate('bbba') == 'bbba'
assert candidate('baabbbbbb') == 'baabbbbbb'
assert candidate('bababaabaa') == 'bababaabaa'
assert candidate('abaaa') == 'abaaa'
assert candidate('abbbbabaab') == 'abbbbabaab'
assert candidate('abba') == 'abba'
assert candidate('bba') == 'bba'
assert candidate('abaabaa') == 'abaabaa'
assert candidate('aabab') == 'aabab'
assert candidate('abaaa') == 'abaaa'
assert candidate('abab') == 'abab'
assert candidate('ab') == 'ab'
assert candidate('ababaaab') == 'ababaaab'
assert candidate('baababbb') == 'baababbb'
assert candidate('bbab') == 'bbab'
assert candidate('bbbbaa') == 'bbbbaa'
assert candidate('bb') == 'bb'
assert candidate('abbabaabaa') == 'abbabaabaa'
assert candidate('a') == 'a'
assert candidate('bbabb') == 'bbabb'
assert candidate('aabaaab') == 'aabaaab'
assert candidate('baaba') == 'baaba'
assert candidate('abbababa') == 'abbababa'
assert candidate('ba') == 'ba'
assert candidate('aa') == 'aa'
assert candidate('aaaabbaa') == 'aaaabbaa'
| 40
|
[
{
"input": "abaa",
"output": "abaa"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "abbaaa",
"output": "abbaaa"
},
{
"input": "abbbabab",
"output": "abbbabab"
},
{
"input": "baaabb",
"output": "baaabb"
},
{
"input": "baabb",
"output": "baabb"
},
{
"input": "aabaab",
"output": "aabaab"
},
{
"input": "bb",
"output": "bb"
}
] |
[
{
"input": "aaabaa",
"output": "aaabaa"
},
{
"input": "baaaaab",
"output": "bbab"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbbaaaa",
"output": "bbbb"
},
{
"input": "ababab",
"output": "ababab"
},
{
"input": "bbbbabab",
"output": "bbbbabab"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "baabbbbbb",
"output": "baabbbbbb"
},
{
"input": "bababaabaa",
"output": "bababaabaa"
},
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "abbbbabaab",
"output": "abbbbabaab"
},
{
"input": "abba",
"output": "abba"
},
{
"input": "bba",
"output": "bba"
},
{
"input": "abaabaa",
"output": "abaabaa"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "abaaa",
"output": "abaaa"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "ab",
"output": "ab"
},
{
"input": "ababaaab",
"output": "ababaaab"
},
{
"input": "baababbb",
"output": "baababbb"
},
{
"input": "bbab",
"output": "bbab"
},
{
"input": "bbbbaa",
"output": "bbbbaa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abbabaabaa",
"output": "abbabaabaa"
},
{
"input": "a",
"output": "a"
},
{
"input": "bbabb",
"output": "bbabb"
},
{
"input": "aabaaab",
"output": "aabaaab"
},
{
"input": "baaba",
"output": "baaba"
},
{
"input": "abbababa",
"output": "abbababa"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aa",
"output": "aa"
},
{
"input": "aaaabbaa",
"output": "aaaabbaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000095
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbaabbaba') == 'bbbabaaaba'
>>> apply_pipeline('baabaaa') == 'baabaaa'
>>> apply_pipeline('abbabaabbb') == 'abbaababaab'
>>> apply_pipeline('aabbb') == 'babaab'
>>> apply_pipeline('baab') == 'baab'
>>> apply_pipeline('abbb') == 'abbb'
>>> apply_pipeline('abaa') == 'abaa'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('abaab', 'aaaab')
s = s.lower()
s = s.lower()
s = s.replace('aabb', 'babaa')
return s
|
[
{
"method": "replace",
"args": [
"abaab",
"aaaab"
]
},
{
"method": "lower",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"aabb",
"babaa"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'b'
assert candidate('bbaabbaba') == 'bbbabaaaba'
assert candidate('baabaaa') == 'baabaaa'
assert candidate('abbabaabbb') == 'abbaababaab'
assert candidate('aabbb') == 'babaab'
assert candidate('baab') == 'baab'
assert candidate('abbb') == 'abbb'
assert candidate('abaa') == 'abaa'
# hidden tests
assert candidate('baabbababa') == 'bbabaaababa'
assert candidate('bb') == 'bb'
assert candidate('aabbbbb') == 'babaabbb'
assert candidate('aabaabbbbb') == 'aaababaabbb'
assert candidate('bbabab') == 'bbabab'
assert candidate('bab') == 'bab'
assert candidate('aabb') == 'babaa'
assert candidate('bbaabbabab') == 'bbbabaaabab'
assert candidate('a') == 'a'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('aabaaaa') == 'aabaaaa'
assert candidate('b') == 'b'
assert candidate('aaaaa') == 'aaaaa'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('abbbbaaa') == 'abbbbaaa'
assert candidate('abbbaba') == 'abbbaba'
assert candidate('aabaab') == 'aaaaab'
assert candidate('bbbbbaaa') == 'bbbbbaaa'
assert candidate('bbaba') == 'bbaba'
assert candidate('bbbbbaaabb') == 'bbbbbababaa'
assert candidate('aabba') == 'babaaa'
assert candidate('abbbbaabb') == 'abbbbbabaa'
assert candidate('bbbabbaa') == 'bbbabbaa'
assert candidate('aabab') == 'aabab'
assert candidate('abbbbbabab') == 'abbbbbabab'
assert candidate('bbb') == 'bbb'
assert candidate('abbaab') == 'abbaab'
assert candidate('babba') == 'babba'
assert candidate('baaabbaa') == 'bababaaaa'
assert candidate('aaabbaab') == 'ababaaaab'
assert candidate('bbbabbaaa') == 'bbbabbaaa'
assert candidate('aabbbbbbaa') == 'babaabbbbaa'
| 40
|
[
{
"input": "b",
"output": "b"
},
{
"input": "bbaabbaba",
"output": "bbbabaaaba"
},
{
"input": "baabaaa",
"output": "baabaaa"
},
{
"input": "abbabaabbb",
"output": "abbaababaab"
},
{
"input": "aabbb",
"output": "babaab"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "abbb",
"output": "abbb"
},
{
"input": "abaa",
"output": "abaa"
}
] |
[
{
"input": "baabbababa",
"output": "bbabaaababa"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "aabbbbb",
"output": "babaabbb"
},
{
"input": "aabaabbbbb",
"output": "aaababaabbb"
},
{
"input": "bbabab",
"output": "bbabab"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aabb",
"output": "babaa"
},
{
"input": "bbaabbabab",
"output": "bbbabaaabab"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "aabaaaa",
"output": "aabaaaa"
},
{
"input": "b",
"output": "b"
},
{
"input": "aaaaa",
"output": "aaaaa"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "abbbbaaa",
"output": "abbbbaaa"
},
{
"input": "abbbaba",
"output": "abbbaba"
},
{
"input": "aabaab",
"output": "aaaaab"
},
{
"input": "bbbbbaaa",
"output": "bbbbbaaa"
},
{
"input": "bbaba",
"output": "bbaba"
},
{
"input": "bbbbbaaabb",
"output": "bbbbbababaa"
},
{
"input": "aabba",
"output": "babaaa"
},
{
"input": "abbbbaabb",
"output": "abbbbbabaa"
},
{
"input": "bbbabbaa",
"output": "bbbabbaa"
},
{
"input": "aabab",
"output": "aabab"
},
{
"input": "abbbbbabab",
"output": "abbbbbabab"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "abbaab",
"output": "abbaab"
},
{
"input": "babba",
"output": "babba"
},
{
"input": "baaabbaa",
"output": "bababaaaa"
},
{
"input": "aaabbaab",
"output": "ababaaaab"
},
{
"input": "bbbabbaaa",
"output": "bbbabbaaa"
},
{
"input": "aabbbbbbaa",
"output": "babaabbbbaa"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 4,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000096
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('baabbaaaa') == 'bAAAbAbAAAAA'
>>> apply_pipeline('baaaaaab') == 'bAAAAAAAbA'
>>> apply_pipeline('baaabab') == 'bAAAAbAAbA'
>>> apply_pipeline('a') == 'A'
>>> apply_pipeline('ababaab') == 'AbAAbAAAbA'
>>> apply_pipeline('baababba') == 'bAAAbAAbAbAA'
>>> apply_pipeline('bbaaab') == 'bAbAAAAbA'
>>> apply_pipeline('baaa') == 'bAAAA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.replace('b', 'aaaba')
s = s.upper()
s = s.replace('AAAB', 'b')
return s
|
[
{
"method": "replace",
"args": [
"b",
"aaaba"
]
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AAAB",
"b"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('baabbaaaa') == 'bAAAbAbAAAAA'
assert candidate('baaaaaab') == 'bAAAAAAAbA'
assert candidate('baaabab') == 'bAAAAbAAbA'
assert candidate('a') == 'A'
assert candidate('ababaab') == 'AbAAbAAAbA'
assert candidate('baababba') == 'bAAAbAAbAbAA'
assert candidate('bbaaab') == 'bAbAAAAbA'
assert candidate('baaa') == 'bAAAA'
# hidden tests
assert candidate('baaaba') == 'bAAAAbAA'
assert candidate('ab') == 'AbA'
assert candidate('bb') == 'bAbA'
assert candidate('baabbaaba') == 'bAAAbAbAAAbAA'
assert candidate('a') == 'A'
assert candidate('bbbbabbbb') == 'bAbAbAbAAbAbAbAbA'
assert candidate('bbb') == 'bAbAbA'
assert candidate('a') == 'A'
assert candidate('bab') == 'bAAbA'
assert candidate('bbaaaa') == 'bAbAAAAA'
assert candidate('baabbabb') == 'bAAAbAbAAbAbA'
assert candidate('abbb') == 'AbAbAbA'
assert candidate('baaaabbb') == 'bAAAAAbAbAbA'
assert candidate('b') == 'bA'
assert candidate('abaa') == 'AbAAA'
assert candidate('aa') == 'AA'
assert candidate('a') == 'A'
assert candidate('baabbab') == 'bAAAbAbAAbA'
assert candidate('bb') == 'bAbA'
assert candidate('bbaabab') == 'bAbAAAbAAbA'
assert candidate('bbb') == 'bAbAbA'
assert candidate('aaaaaa') == 'AAAAAA'
assert candidate('a') == 'A'
assert candidate('aaaabaa') == 'AAAAbAAA'
assert candidate('b') == 'bA'
assert candidate('abbba') == 'AbAbAbAA'
assert candidate('b') == 'bA'
assert candidate('b') == 'bA'
assert candidate('aab') == 'AAbA'
assert candidate('aaabbbbb') == 'AAAbAbAbAbAbA'
assert candidate('ab') == 'AbA'
assert candidate('b') == 'bA'
| 40
|
[
{
"input": "baabbaaaa",
"output": "bAAAbAbAAAAA"
},
{
"input": "baaaaaab",
"output": "bAAAAAAAbA"
},
{
"input": "baaabab",
"output": "bAAAAbAAbA"
},
{
"input": "a",
"output": "A"
},
{
"input": "ababaab",
"output": "AbAAbAAAbA"
},
{
"input": "baababba",
"output": "bAAAbAAbAbAA"
},
{
"input": "bbaaab",
"output": "bAbAAAAbA"
},
{
"input": "baaa",
"output": "bAAAA"
}
] |
[
{
"input": "baaaba",
"output": "bAAAAbAA"
},
{
"input": "ab",
"output": "AbA"
},
{
"input": "bb",
"output": "bAbA"
},
{
"input": "baabbaaba",
"output": "bAAAbAbAAAbAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bbbbabbbb",
"output": "bAbAbAbAAbAbAbAbA"
},
{
"input": "bbb",
"output": "bAbAbA"
},
{
"input": "a",
"output": "A"
},
{
"input": "bab",
"output": "bAAbA"
},
{
"input": "bbaaaa",
"output": "bAbAAAAA"
},
{
"input": "baabbabb",
"output": "bAAAbAbAAbAbA"
},
{
"input": "abbb",
"output": "AbAbAbA"
},
{
"input": "baaaabbb",
"output": "bAAAAAbAbAbA"
},
{
"input": "b",
"output": "bA"
},
{
"input": "abaa",
"output": "AbAAA"
},
{
"input": "aa",
"output": "AA"
},
{
"input": "a",
"output": "A"
},
{
"input": "baabbab",
"output": "bAAAbAbAAbA"
},
{
"input": "bb",
"output": "bAbA"
},
{
"input": "bbaabab",
"output": "bAbAAAbAAbA"
},
{
"input": "bbb",
"output": "bAbAbA"
},
{
"input": "aaaaaa",
"output": "AAAAAA"
},
{
"input": "a",
"output": "A"
},
{
"input": "aaaabaa",
"output": "AAAAbAAA"
},
{
"input": "b",
"output": "bA"
},
{
"input": "abbba",
"output": "AbAbAbAA"
},
{
"input": "b",
"output": "bA"
},
{
"input": "b",
"output": "bA"
},
{
"input": "aab",
"output": "AAbA"
},
{
"input": "aaabbbbb",
"output": "AAAbAbAbAbAbA"
},
{
"input": "ab",
"output": "AbA"
},
{
"input": "b",
"output": "bA"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000097
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('bbab') == 'BBAB'
>>> apply_pipeline('aababa') == 'AABABA'
>>> apply_pipeline('bbbabb') == 'BBBABB'
>>> apply_pipeline('aba') == 'ABA'
>>> apply_pipeline('baaababba') == 'BaBBA'
>>> apply_pipeline('aabbaaab') == 'AABBAAAB'
>>> apply_pipeline('aaba') == 'AABA'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.upper()
s = s.replace('AAABA', 'a')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "upper",
"args": []
},
{
"method": "replace",
"args": [
"AAABA",
"a"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('b') == 'B'
assert candidate('bbab') == 'BBAB'
assert candidate('aababa') == 'AABABA'
assert candidate('bbbabb') == 'BBBABB'
assert candidate('aba') == 'ABA'
assert candidate('baaababba') == 'BaBBA'
assert candidate('aabbaaab') == 'AABBAAAB'
assert candidate('aaba') == 'AABA'
# hidden tests
assert candidate('aababa') == 'AABABA'
assert candidate('abbabba') == 'ABBABBA'
assert candidate('babba') == 'BABBA'
assert candidate('bbaabba') == 'BBAABBA'
assert candidate('b') == 'B'
assert candidate('bbaaa') == 'BBAAA'
assert candidate('abbaaba') == 'ABBAABA'
assert candidate('aabbbab') == 'AABBBAB'
assert candidate('bba') == 'BBA'
assert candidate('aaba') == 'AABA'
assert candidate('bbb') == 'BBB'
assert candidate('baba') == 'BABA'
assert candidate('bbbbbbaabb') == 'BBBBBBAABB'
assert candidate('bbabaabbab') == 'BBABAABBAB'
assert candidate('ab') == 'AB'
assert candidate('bbb') == 'BBB'
assert candidate('abaabbbb') == 'ABAABBBB'
assert candidate('abbbbbbaa') == 'ABBBBBBAA'
assert candidate('aaabbabaa') == 'AAABBABAA'
assert candidate('baabba') == 'BAABBA'
assert candidate('abaab') == 'ABAAB'
assert candidate('babb') == 'BABB'
assert candidate('bbabaa') == 'BBABAA'
assert candidate('aaabbaaaab') == 'AAABBAAAAB'
assert candidate('bbaaabbaa') == 'BBAAABBAA'
assert candidate('babbbaaa') == 'BABBBAAA'
assert candidate('bbbbaaaa') == 'BBBBAAAA'
assert candidate('aaabbabbb') == 'AAABBABBB'
assert candidate('a') == 'A'
assert candidate('abbbbabbba') == 'ABBBBABBBA'
assert candidate('aaabbbaba') == 'AAABBBABA'
assert candidate('a') == 'A'
| 40
|
[
{
"input": "b",
"output": "B"
},
{
"input": "bbab",
"output": "BBAB"
},
{
"input": "aababa",
"output": "AABABA"
},
{
"input": "bbbabb",
"output": "BBBABB"
},
{
"input": "aba",
"output": "ABA"
},
{
"input": "baaababba",
"output": "BaBBA"
},
{
"input": "aabbaaab",
"output": "AABBAAAB"
},
{
"input": "aaba",
"output": "AABA"
}
] |
[
{
"input": "aababa",
"output": "AABABA"
},
{
"input": "abbabba",
"output": "ABBABBA"
},
{
"input": "babba",
"output": "BABBA"
},
{
"input": "bbaabba",
"output": "BBAABBA"
},
{
"input": "b",
"output": "B"
},
{
"input": "bbaaa",
"output": "BBAAA"
},
{
"input": "abbaaba",
"output": "ABBAABA"
},
{
"input": "aabbbab",
"output": "AABBBAB"
},
{
"input": "bba",
"output": "BBA"
},
{
"input": "aaba",
"output": "AABA"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "baba",
"output": "BABA"
},
{
"input": "bbbbbbaabb",
"output": "BBBBBBAABB"
},
{
"input": "bbabaabbab",
"output": "BBABAABBAB"
},
{
"input": "ab",
"output": "AB"
},
{
"input": "bbb",
"output": "BBB"
},
{
"input": "abaabbbb",
"output": "ABAABBBB"
},
{
"input": "abbbbbbaa",
"output": "ABBBBBBAA"
},
{
"input": "aaabbabaa",
"output": "AAABBABAA"
},
{
"input": "baabba",
"output": "BAABBA"
},
{
"input": "abaab",
"output": "ABAAB"
},
{
"input": "babb",
"output": "BABB"
},
{
"input": "bbabaa",
"output": "BBABAA"
},
{
"input": "aaabbaaaab",
"output": "AAABBAAAAB"
},
{
"input": "bbaaabbaa",
"output": "BBAAABBAA"
},
{
"input": "babbbaaa",
"output": "BABBBAAA"
},
{
"input": "bbbbaaaa",
"output": "BBBBAAAA"
},
{
"input": "aaabbabbb",
"output": "AAABBABBB"
},
{
"input": "a",
"output": "A"
},
{
"input": "abbbbabbba",
"output": "ABBBBABBBA"
},
{
"input": "aaabbbaba",
"output": "AAABBBABA"
},
{
"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/000098
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('aaabbba') == 'aaabbba'
>>> apply_pipeline('baabba') == 'baabba'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('babbbaaaba') == 'babbbaaaba'
>>> apply_pipeline('bbb') == 'bbb'
>>> apply_pipeline('a') == 'a'
>>> apply_pipeline('abbbbaa') == 'abbbbaa'
>>> apply_pipeline('aba') == 'aba'
"""
raise NotImplementedError()
|
def apply_pipeline(s: str) -> str:
"""Canonical solution (auto-generated)."""
s = s.upper()
s = s.lower()
s = s.replace('aaaaa', 'a')
return s
|
[
{
"method": "upper",
"args": []
},
{
"method": "lower",
"args": []
},
{
"method": "replace",
"args": [
"aaaaa",
"a"
]
}
] |
from typing import Callable
def check(candidate: Callable[[str], str]) -> None:
# examples from the prompt
assert candidate('aaabbba') == 'aaabbba'
assert candidate('baabba') == 'baabba'
assert candidate('a') == 'a'
assert candidate('babbbaaaba') == 'babbbaaaba'
assert candidate('bbb') == 'bbb'
assert candidate('a') == 'a'
assert candidate('abbbbaa') == 'abbbbaa'
assert candidate('aba') == 'aba'
# hidden tests
assert candidate('bbbbbbbab') == 'bbbbbbbab'
assert candidate('bbbbabbbb') == 'bbbbabbbb'
assert candidate('abbbaaaaa') == 'abbba'
assert candidate('bbb') == 'bbb'
assert candidate('bbaabbb') == 'bbaabbb'
assert candidate('bbb') == 'bbb'
assert candidate('ababbabb') == 'ababbabb'
assert candidate('abab') == 'abab'
assert candidate('baaabaabbb') == 'baaabaabbb'
assert candidate('baaaaa') == 'ba'
assert candidate('bab') == 'bab'
assert candidate('aaaabbbb') == 'aaaabbbb'
assert candidate('baba') == 'baba'
assert candidate('babababbbb') == 'babababbbb'
assert candidate('abbbababab') == 'abbbababab'
assert candidate('bbbabaab') == 'bbbabaab'
assert candidate('aabaab') == 'aabaab'
assert candidate('aaba') == 'aaba'
assert candidate('bbbaab') == 'bbbaab'
assert candidate('bbbbba') == 'bbbbba'
assert candidate('baa') == 'baa'
assert candidate('b') == 'b'
assert candidate('abaaabbaa') == 'abaaabbaa'
assert candidate('bbaa') == 'bbaa'
assert candidate('baa') == 'baa'
assert candidate('bbbaa') == 'bbbaa'
assert candidate('abbabab') == 'abbabab'
assert candidate('abaabaaaab') == 'abaabaaaab'
assert candidate('aaaab') == 'aaaab'
assert candidate('b') == 'b'
assert candidate('abbaabb') == 'abbaabb'
assert candidate('a') == 'a'
| 40
|
[
{
"input": "aaabbba",
"output": "aaabbba"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "a",
"output": "a"
},
{
"input": "babbbaaaba",
"output": "babbbaaaba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbbbaa",
"output": "abbbbaa"
},
{
"input": "aba",
"output": "aba"
}
] |
[
{
"input": "bbbbbbbab",
"output": "bbbbbbbab"
},
{
"input": "bbbbabbbb",
"output": "bbbbabbbb"
},
{
"input": "abbbaaaaa",
"output": "abbba"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "bbaabbb",
"output": "bbaabbb"
},
{
"input": "bbb",
"output": "bbb"
},
{
"input": "ababbabb",
"output": "ababbabb"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "baaabaabbb",
"output": "baaabaabbb"
},
{
"input": "baaaaa",
"output": "ba"
},
{
"input": "bab",
"output": "bab"
},
{
"input": "aaaabbbb",
"output": "aaaabbbb"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "babababbbb",
"output": "babababbbb"
},
{
"input": "abbbababab",
"output": "abbbababab"
},
{
"input": "bbbabaab",
"output": "bbbabaab"
},
{
"input": "aabaab",
"output": "aabaab"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "bbbaab",
"output": "bbbaab"
},
{
"input": "bbbbba",
"output": "bbbbba"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "b",
"output": "b"
},
{
"input": "abaaabbaa",
"output": "abaaabbaa"
},
{
"input": "bbaa",
"output": "bbaa"
},
{
"input": "baa",
"output": "baa"
},
{
"input": "bbbaa",
"output": "bbbaa"
},
{
"input": "abbabab",
"output": "abbabab"
},
{
"input": "abaabaaaab",
"output": "abaabaaaab"
},
{
"input": "aaaab",
"output": "aaaab"
},
{
"input": "b",
"output": "b"
},
{
"input": "abbaabb",
"output": "abbaabb"
},
{
"input": "a",
"output": "a"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 3,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
pbe-world/000099
|
apply_pipeline
|
from typing import List
def apply_pipeline(s: str) -> str:
"""Apply a fixed string-manipulation pipeline to the input string `s`.
The pipeline consists of several string method calls such as:
s = s.replace(old, new)
s = s.upper()
s = s.lower()
s = s.strip(chars)
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('baa') == 'baa'
>>> apply_pipeline('bbba') == 'bbba'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('baba') == 'baba'
>>> apply_pipeline('aababa') == 'aababa'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('b') == 'b'
>>> apply_pipeline('bbaab') == 'bbaab'
"""
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('baa') == 'baa'
assert candidate('bbba') == 'bbba'
assert candidate('b') == 'b'
assert candidate('baba') == 'baba'
assert candidate('aababa') == 'aababa'
assert candidate('b') == 'b'
assert candidate('b') == 'b'
assert candidate('bbaab') == 'bbaab'
# hidden tests
assert candidate('b') == 'b'
assert candidate('a') == 'a'
assert candidate('aabaaba') == 'aabaaba'
assert candidate('bb') == 'bb'
assert candidate('abababaa') == 'abababaa'
assert candidate('bbbba') == 'bbbba'
assert candidate('abaaabbaa') == 'abaaabbaa'
assert candidate('aaa') == 'aaa'
assert candidate('aaba') == 'aaba'
assert candidate('aba') == 'aba'
assert candidate('ababaab') == 'ababaab'
assert candidate('aabba') == 'aabba'
assert candidate('abb') == 'abb'
assert candidate('baaabab') == 'baaabab'
assert candidate('aaabbab') == 'aaabbab'
assert candidate('baab') == 'baab'
assert candidate('baabaabbb') == 'baabaabbb'
assert candidate('baabba') == 'baabba'
assert candidate('aaaa') == 'aaaa'
assert candidate('ababbbbb') == 'ababbbbb'
assert candidate('bbaab') == 'bbaab'
assert candidate('abbbabaab') == 'abbbabaab'
assert candidate('a') == 'a'
assert candidate('abbaaa') == 'abbaaa'
assert candidate('bbabaa') == 'bbabaa'
assert candidate('bbbabab') == 'bbbabab'
assert candidate('bbbaaabbab') == 'bbbaaabbab'
assert candidate('aaabbb') == 'aaabbb'
assert candidate('abab') == 'abab'
assert candidate('baab') == 'baab'
assert candidate('ba') == 'ba'
assert candidate('aaaab') == 'aaaab'
| 40
|
[
{
"input": "baa",
"output": "baa"
},
{
"input": "bbba",
"output": "bbba"
},
{
"input": "b",
"output": "b"
},
{
"input": "baba",
"output": "baba"
},
{
"input": "aababa",
"output": "aababa"
},
{
"input": "b",
"output": "b"
},
{
"input": "b",
"output": "b"
},
{
"input": "bbaab",
"output": "bbaab"
}
] |
[
{
"input": "b",
"output": "b"
},
{
"input": "a",
"output": "a"
},
{
"input": "aabaaba",
"output": "aabaaba"
},
{
"input": "bb",
"output": "bb"
},
{
"input": "abababaa",
"output": "abababaa"
},
{
"input": "bbbba",
"output": "bbbba"
},
{
"input": "abaaabbaa",
"output": "abaaabbaa"
},
{
"input": "aaa",
"output": "aaa"
},
{
"input": "aaba",
"output": "aaba"
},
{
"input": "aba",
"output": "aba"
},
{
"input": "ababaab",
"output": "ababaab"
},
{
"input": "aabba",
"output": "aabba"
},
{
"input": "abb",
"output": "abb"
},
{
"input": "baaabab",
"output": "baaabab"
},
{
"input": "aaabbab",
"output": "aaabbab"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "baabaabbb",
"output": "baabaabbb"
},
{
"input": "baabba",
"output": "baabba"
},
{
"input": "aaaa",
"output": "aaaa"
},
{
"input": "ababbbbb",
"output": "ababbbbb"
},
{
"input": "bbaab",
"output": "bbaab"
},
{
"input": "abbbabaab",
"output": "abbbabaab"
},
{
"input": "a",
"output": "a"
},
{
"input": "abbaaa",
"output": "abbaaa"
},
{
"input": "bbabaa",
"output": "bbabaa"
},
{
"input": "bbbabab",
"output": "bbbabab"
},
{
"input": "bbbaaabbab",
"output": "bbbaaabbab"
},
{
"input": "aaabbb",
"output": "aaabbb"
},
{
"input": "abab",
"output": "abab"
},
{
"input": "baab",
"output": "baab"
},
{
"input": "ba",
"output": "ba"
},
{
"input": "aaaab",
"output": "aaaab"
}
] |
{
"alphabet": [
"a",
"b"
],
"alphabet_size": 2,
"num_programs": 2,
"num_examples": 8,
"num_tests": 32,
"generation_params": {
"n_inputs_for_examples": 32,
"l_min": 1,
"l_max": 10,
"pipeline_L_min": 1,
"pipeline_L_max": 5
},
"split": "test",
"version": "1.0.0"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.