task_id stringclasses 161
values | condition stringclasses 10
values | entry_point stringclasses 155
values | code stringlengths 41 2.13k | spec stringclasses 161
values | oracle_pass bool 2
classes | mutation_site stringclasses 15
values | mutation_from stringclasses 3
values | difficulty stringclasses 0
values | contest_date stringclasses 0
values | judge stringclasses 5
values | judge_model stringclasses 5
values | prompt_variant stringclasses 2
values | rep int64 0 2 | said_correct bool 2
classes | confidence int64 0 100 | quality int64 0 5 | reason stringlengths 59 4.93k | json_mode stringclasses 3
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 90 | 2 | The implementation fails to correctly separate groups when spaces appear within a group, as it adds non-space characters to the group before checking if the group is complete, leading to concatenated groups in some cases. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | true | 95 | 5 | Correctly ignores spaces, tracks nesting depth with a counter, collects characters into a group, and appends each balanced group when the counter returns to zero; behavior matches the specification and example for all valid inputs (balanced, non-overlapping groups). | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | true | 100 | 5 | Correctly accumulates characters while tracking balance, ignores spaces, and splits groups when the parenthesis counter returns to zero; matches the given example and handles all valid balanced, non-nested group inputs as specified. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | true | 96 | 5 | The function correctly ignores spaces, tracks balance with a counter, accumulates characters into a group, and appends each completed balanced group to the result. It behaves as specified for any string composed of multiple, non-nested balanced parenthesis groups with optional spaces between/within them. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those. It uses a counter to track the balance of the parentheses and appends each group to the results list when the counter reaches zero, indicating a balanced... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those. It uses a counter to track the balance of the parentheses and appends each group to the results list when the counter reaches zero, indicating a balanced... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those. It uses a counter to track the balance of the parentheses and appends each group to the results list when the counter reaches zero. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses using a counter. It ignores spaces, builds each balanced group as it encounters them, and appends the group to the results list whenever the balance returns to zero. This matches the specification exactly: it separates non-ne... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses with a counter (cnt). It ignores spaces, builds each balanced group as characters are processed, and appends the group to results whenever the counter returns to zero (indicating a complete balanced group). The example input ... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses using a counter. It ignores spaces, builds groups of balanced parentheses, and appends each complete balanced group to the results list when the counter returns to zero. The example input '( ) (( )) (( )( ))' is correctly pro... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 0 | true | 95 | 5 | The implementation correctly handles the task by tracking parenthesis balance with a counter, accumulating characters into groups while ignoring spaces, and appending complete groups (when counter reaches 0) to the results list. Testing with the provided example and edge cases confirms it produces the expected output. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 1 | true | 95 | 5 | The implementation correctly handles the task by tracking parenthesis balance with a counter, accumulating characters into groups while ignoring spaces, and appending complete groups (when counter reaches 0) to the results list. Testing with the provided example and edge cases confirms it produces the expected output. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 2 | true | 95 | 5 | The implementation correctly handles the task by tracking parenthesis balance with a counter, accumulating characters into groups while ignoring spaces, and appending complete groups (when counter reaches 0) to the results list. Testing with the provided example and edge cases confirms it produces the expected output. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 0 | false | 90 | 2 | The implementation fails to correctly separate groups when there are spaces within parentheses, as it includes spaces in the group string before checking for cnt == 0, leading to incorrect output for the given example. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 1 | false | 95 | 2 | The implementation fails to correctly separate groups when spaces appear inside parentheses, as it includes spaces in the group string before filtering them out, which disrupts the zero-count detection logic for balanced groups. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 2 | false | 90 | 2 | The implementation fails to correctly separate groups when spaces appear within parentheses, as it adds all non-space characters to the current group regardless of grouping boundaries, leading to incorrect concatenation of separate groups. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 0 | true | 96 | 5 | The function correctly ignores spaces, tracks balance with a counter, accumulates non-space parentheses into a current group, and appends each group when the balance returns to zero. This yields the expected separation of balanced, non-overlapping parenthesis groups, including the provided example. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 1 | true | 95 | 5 | The function correctly ignores spaces, tracks balance with a counter, accumulates non-space characters into groups, and appends each balanced group when the counter returns to zero. It behaves as required for multiple non-nested balanced parenthesis groups and matches the example output. | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 2 | true | 96 | 5 | The function correctly ignores spaces, accumulates characters into groups, and uses a counter to detect when each balanced top-level parenthesis group ends, appending it to the result. For inputs consisting of multiple, non-nested balanced groups as specified, including the example, it returns the correct list of group... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 0 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those strings. It uses a counter to track the nesting level of the parentheses and appends each character to the current group, resetting the group when the cou... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 1 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those strings. It uses a counter to track the balance of the parentheses and appends each group to the results list when the counter reaches zero, indicating a ... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 2 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those strings. It uses a counter to track the nesting level of the parentheses and appends each character to the current group, resetting the group when the cou... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 0 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses using a counter (cnt). It ignores spaces, builds each balanced group as characters are processed, and appends the group to results whenever the counter returns to zero — indicating a complete, balanced group. The example inpu... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 1 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses using a counter (cnt). It ignores spaces, accumulates non-space characters into a group, and whenever the balance returns to zero (indicating a complete balanced group), it adds that group to the results list and resets the g... | json_schema |
HumanEval/1 | baseline | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 2 | true | 1 | 1 | The implementation correctly processes the input string by tracking the balance of parentheses using a counter (cnt). It ignores spaces, accumulates non-space characters into a group, and whenever the balance returns to zero (indicating a complete balanced group), it adds that group to the results list and resets the g... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | false | 95 | 1 | The implementation has a fundamental logic error in its counter mechanism. It increments `cnt` for every non-'(' character (including ')' and other characters), which breaks the balance tracking. The docstring examples show it produces ['(', ')'] instead of ['()'], and ['(', '('] instead of ['(())'], demonstrating it f... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | false | 95 | 1 | The implementation has a fundamental logic error in its counter mechanism. It increments `cnt` for every non-'(' character (including ')' and other characters), which breaks the balance tracking. The docstring examples show it produces ['(', ')'] instead of ['()'], and ['(', '('] instead of ['(())'], demonstrating it f... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | false | 95 | 1 | The implementation has a fundamental logic error in its counter mechanism. It increments `cnt` for every non-'(' character (including ')' and other characters), which breaks the balance tracking. The docstring examples show it produces ['(', ')'] instead of ['()'], and ['(', '('] instead of ['(())'], demonstrating it f... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | false | 95 | 1 | The implementation fails to correctly separate balanced groups and ignores spaces incorrectly; it produces single-character strings or incomplete groups instead of balanced parenthesis strings as required by the specification. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | false | 95 | 1 | The implementation fails to correctly separate balanced, non-nested groups as required. It incorrectly handles spaces and grouping logic, producing outputs like single characters or incomplete groups, which do not match the expected results in the specification. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 95 | 1 | The implementation fails to correctly separate balanced groups and ignores spaces incorrectly, producing outputs like ['('] for valid inputs instead of the expected list of balanced strings. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 0 | false | 100 | 2 | The function’s logic does not match the described (and misdocumented) behavior nor the task spec. It counts any non-'(' character (including letters, digits, punctuation) as closing, and always appends any non-space character to the current group. For inputs with non-space non-parenthesis characters, groups will be inc... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 1 | false | 99 | 2 | The function merges all groups into a single string and can include non-parenthesis characters, rather than returning each balanced parenthesis group as its own string while ignoring spaces, so it fails the required behavior on the provided example and in general. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 100 | 2 | The function treats any non-'(' character (including letters) as closing and only ignores spaces for grouping, so it fails on general inputs with other characters and will split incorrectly; it also depends on a flawed counter logic inconsistent with balanced-parentheses tracking even though it happens to match the giv... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | false | 1 | 0 | The implementation does not correctly separate groups of nested parentheses. It only appends individual parentheses to the result list and stops once a non-parenthesis character is encountered. The implementation also does not handle the case where there are multiple groups of parentheses correctly. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | false | 1 | 0 | The candidate implementation does not correctly separate groups of nested parentheses into separate strings. It incorrectly appends individual parentheses as separate strings to the result list and omits subsequent characters once a non-parenthesis character is encountered. The implementation also does not ignore space... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | false | 0 | 1 | The implementation does not correctly separate groups of nested parentheses and returns individual characters instead of groups. | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | false | 1 | 1 | The implementation has multiple critical flaws:
1. The logic for counting parentheses is reversed: it increments `cnt` for any character that is not '(', and decrements only for ')'. This means spaces and other characters (even non-parentheses) incorrectly increase the counter, breaking the balance logic.
2. The func... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | false | 1 | 1 | The implementation has multiple critical flaws:
1. The logic for counting parentheses is reversed: it increments `cnt` for any character that is not '(', and decrements only for ')'. This means spaces and other characters (even non-parentheses) incorrectly increase the counter, breaking the balance logic.
2. The func... | json_schema |
HumanEval/1 | consistent_bug_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
"""Traverse paren_string and return a list of single-parenthesis strings for leading parentheses prior to any non-parenthesis characters.
Iterates through paren_string character by character. For each '(' or ')' encountered before ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | false | 1 | 1 | The implementation has multiple critical flaws:
1. The logic for counting parentheses is reversed: it increments `cnt` for any character that is not '(', and decrements only for ')'. This means spaces and other characters (even non-parentheses) incorrectly increase the counter, breaking the balance logic.
2. The func... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | true | 95 | 4 | The implementation correctly separates balanced parenthesis groups by tracking nesting depth with a counter, accumulating characters while ignoring spaces, and appending complete groups when the counter returns to zero. The logic handles the provided example and edge cases properly, though the obfuscated variable names... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | true | 95 | 4 | The implementation correctly separates balanced parenthesis groups by tracking nesting depth with a counter, accumulating characters while ignoring spaces, and appending complete groups when the counter returns to zero. The logic handles the provided example and edge cases properly, though the obfuscated variable names... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | true | 95 | 4 | The implementation correctly separates balanced parenthesis groups by tracking nesting depth with a counter, accumulating characters while ignoring spaces, and appending complete groups when the counter returns to zero. The logic handles the provided example and edge cases properly, though the obfuscated variable names... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | true | 95 | 4 | The implementation correctly tracks balance count, ignores spaces, and appends complete balanced groups to the result list, matching the provided example and specification for valid inputs. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | true | 95 | 4 | The implementation correctly tracks nesting depth, ignores spaces, and appends balanced groups to the result list, matching the example and specification for valid inputs. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | true | 95 | 4 | The implementation correctly tracks balance count, ignores spaces, and appends complete balanced groups to the result list, matching the provided example and specification for valid inputs. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | true | 93 | 5 | The function correctly ignores spaces, tracks balance of parentheses, and splits the input into separate balanced groups as required; its behavior matches the specification and the given example for all valid inputs of balanced, non-nested groups. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | true | 96 | 5 | The implementation correctly ignores spaces, tracks balanced groups using a counter, accumulates characters into groups, and appends each non-empty group when the balance returns to zero, matching the specified behavior for all valid inputs. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | true | 96 | 4 | Correctly tracks nesting depth, strips spaces, and segments at each point where the parentheses balance returns to zero; behavior matches the example and the stated requirements for all valid inputs of balanced, non-overlapping groups. | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 1 | 1 | The implementation correctly separates the groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those groups. It iterates over the input string, maintaining a count of open parentheses and appending characters to the current group. When the count reaches z... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | true | 1 | 0 | The provided implementation correctly separates groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those groups. It iterates over the input string, maintaining a count of open parentheses and appending characters to the current group. When the count reac... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | true | 1 | 0 | The provided implementation correctly separates groups of nested parentheses into separate strings, ignoring any spaces in the input string, and returns the list of those strings. It iterates over the input string, tracking the balance of open and close parentheses, and appends each group to the results list when the b... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | true | 0 | 0 | The implementation correctly identifies balanced parentheses groups by tracking the nesting level with a counter (cnt). It ignores spaces, builds each group character by character, and appends a group to the results list only when the counter returns to zero (indicating a complete balanced group). The use of variables ... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | true | 1 | 1 | The implementation correctly identifies balanced parentheses groups by tracking the nesting level with a counter (cnt). It ignores spaces by only appending non-space characters to the current group. When the counter returns to zero, it means a balanced group is complete, and the group is added to results if non-empty. ... | json_schema |
HumanEval/1 | extract_constants | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | true | 1 | 1 | The implementation correctly identifies balanced parentheses groups by tracking the nesting level with a counter (cnt). It ignores spaces by only appending non-space characters to the current group. When the counter returns to zero, it means a balanced group is complete, and the group is added to results if not empty. ... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but the docstring claims it returns groups in reverse order, which contradicts the specification. The actual runtime behavior matches the specification (returns groups in order of appearance), but the misleading docstring and example in ... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but the docstring claims it returns groups in reverse order, which contradicts the specification. The actual runtime behavior matches the specification (returns groups in order of appearance), but the misleading docstring and example in ... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but the docstring claims it returns groups in reverse order, which contradicts the specification. The actual runtime behavior matches the specification (returns groups in order of appearance), but the misleading docstring and example in ... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | false | 95 | 3 | The implementation returns groups in reverse order of appearance, but the specification requires the list in the original order as shown in the example. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | false | 90 | 3 | The implementation returns groups in reverse order of appearance, but the specification requires the list in the original order as shown in the example. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 90 | 3 | The implementation returns groups in reverse order of appearance, but the specification requires the list in the original order as shown in the example. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | false | 95 | 3 | The code correctly splits balanced, non-nested parenthesis groups and ignores spaces, but it returns them in the original order rather than the specified order in the example (which is also described in the docstring as reverse order), so it does not match the stated behavior/example. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | false | 90 | 4 | The function correctly groups balanced parenthesis substrings and ignores spaces, but it returns the groups in reverse order of appearance, while the specification requires preserving the original order. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 100 | 3 | The function correctly groups balanced parenthesis substrings while ignoring spaces, but it returns them in reverse order of appearance, contrary to the specification which requires preserving the original order (e.g., expected ['()', '(())', '(()())'] but this returns ['(()())', '(())', '()']). | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | false | 1 | 0 | The implementation returns the groups in reverse order of appearance, whereas the specification does not require this. The implementation's docstring also mentions this, which further indicates that it does not satisfy the specification. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | false | 1 | 0 | The implementation returns the list of groups in reverse order of appearance, whereas the specification does not require this. The implementation should return the groups in the order they appear in the input string. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | false | 1 | 0 | The implementation returns the groups in reverse order of appearance, whereas the specification does not require this. The implementation should return the groups in the order they appear in the input string. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | false | 1 | 1 | The implementation correctly identifies balanced parentheses groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and docstring) require the groups to be returned in reverse order of appearance. The example input '( ) (( )) (( )( ))' should return ['(()())', '(())', ... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | false | 1 | 1 | The implementation correctly identifies balanced parentheses groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and the docstring example) require the groups to be returned in reverse order of appearance. The example in the docstring shows the expected output as ['... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | false | 1 | 0 | The implementation correctly identifies balanced parentheses groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and the example output) requires the groups to be returned in reverse order of appearance. The docstring explicitly states 'return the list of those in r... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 0 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but returns them in the wrong order. The specification expects ['()', '(())', '(()())'] but the implementation returns ['()', '(())', '(()())'] in the correct order. However, the docstring claims it returns groups in 'reverse order of ap... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 1 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but returns them in the wrong order. The specification expects ['()', '(())', '(()())'] but the implementation returns ['()', '(())', '(()())'] in the correct order. However, the docstring claims it returns groups in 'reverse order of ap... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 2 | false | 95 | 3 | The implementation correctly identifies and separates balanced parenthesis groups, but returns them in the wrong order. The specification expects ['()', '(())', '(()())'] but the implementation returns ['()', '(())', '(()())'] in the correct order. However, the docstring claims it returns groups in 'reverse order of ap... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 0 | false | 95 | 2 | The implementation returns groups in reverse order of appearance due to appending when cnt==0, but the specification requires the original order as shown in the example, making it incorrect for that requirement. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 1 | false | 95 | 2 | The implementation returns groups in reverse order of appearance, but the specification requires the list in the original order as shown in the example output ['()', '(())', '(()())']. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 2 | false | 95 | 2 | The implementation returns groups in reverse order of appearance, but the specification requires the list in the original order as shown in the example. | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 0 | false | 95 | 3 | The function correctly groups balanced parenthesis substrings and ignores spaces, but it returns the groups in their original order of appearance rather than any specified reverse order; the example in the task expects ['()', '(())', '(()())'], which this implementation produces, but the docstring’s reverse-order claim... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 1 | false | 95 | 4 | The implementation returns the groups in the order they appear in the string, but the specification requires returning them in that same order as shown in the example; however, this implementation’s docstring mentions reverse order but the actual behavior matches the example. Functionally it satisfies grouping, balanci... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 2 | false | 100 | 4 | The implementation parses groups correctly but returns them in the original left-to-right order, while the task specification requires the list of groups in that same order (as shown in the example). The docstring’s mention of reverse order is not part of the spec, and the behavior does not match the example output: th... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 0 | false | 1 | 0 | The candidate implementation returns the list of groups in reverse order of appearance, whereas the task specification does not specify any particular order. However, the provided unit test in the task specification suggests that the order should be the order of appearance, not reverse order. The candidate implementati... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 1 | false | 1 | 0 | The candidate implementation returns the list of groups in reverse order of appearance, whereas the task specification does not specify any particular order. However, the provided unit test in the task specification suggests that the order should be the order of appearance, not reverse order. The candidate implementati... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 2 | false | 1 | 0 | The candidate implementation returns the list of groups in reverse order of appearance, whereas the task specification does not specify any particular order. However, the provided unit test in the task specification suggests that the order should be the order of appearance, not reverse order. The candidate implementati... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 0 | false | 1 | 0 | The implementation correctly identifies balanced parentheses groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and the example output) requires the groups to be returned in reverse order of appearance. The docstring explicitly states 'return the list of those in r... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 1 | false | 1 | 1 | The implementation correctly identifies balanced paren groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and docstring) require them in reverse order of appearance. The example in the docstring shows ['(()())', '(())', '()'] as the expected output, which is the re... | json_schema |
HumanEval/1 | misleading_doc | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those in reverse order of appearance.
Separate groups... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 2 | false | 1 | 0 | The implementation correctly identifies balanced parentheses groups and ignores spaces, but it returns the groups in the order of appearance, while the specification (and the example output) requires the groups to be returned in reverse order of appearance. The docstring explicitly states 'return the list of those in r... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | false | 85 | 2 | The implementation has a logic error in the counter increment. It increments `cnt` for any character that is not '(', including ')' characters, which causes incorrect counting. For example, with input '( )', it would increment cnt for the ')' twice (once in the first if statement and once in the second if statement), l... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | false | 85 | 2 | The implementation has a logic error in the counter increment. It increments `cnt` for any character that is not '(', including ')' characters, which causes incorrect counting. For example, with input '( )', it would increment cnt for the ')' twice (once in the first if statement and once in the second if statement), l... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | false | 85 | 2 | The implementation has a logic error in the counter increment. It increments `cnt` for any character that is not '(', including ')' characters, which causes incorrect counting. For example, with input '( )', it would increment cnt for the ')' twice (once in the first if statement and once in the second if statement), l... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | false | 90 | 2 | The implementation incorrectly increments cnt for characters other than '(' (including ')'), which breaks the balancing logic; it should only increment for '(' and decrement for ')'. | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | false | 90 | 2 | The implementation incorrectly increments cnt for characters other than '(' (including ')'), which breaks the balancing logic. It fails to correctly identify separate balanced groups, as shown by the example where it would produce incorrect output. | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 95 | 2 | The implementation incorrectly increments cnt for characters other than '(' (including ')'), which breaks the balancing logic. It should only increment for '(' and decrement for ')'. This causes incorrect grouping for nested parentheses. | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | gpt | openai/gpt-5.1 | default | 0 | false | 91 | 2 | The implementation mismanages the balance counter: it increments on any character that is not '(', including spaces, and decrements on ')', which breaks the intended tracking of open/close parentheses. This happens to work for the example but would fail if other non-space characters appeared, so it does not robustly sa... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | gpt | openai/gpt-5.1 | default | 1 | false | 95 | 2 | The counter logic is inverted: it increments on any non-'(' character, then decrements only on ')', causing incorrect grouping and failures on many valid inputs (e.g., it breaks on leading spaces, or on more complex balanced groups). Thus the runtime behavior does not reliably separate balanced parenthesis groups as sp... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 92 | 2 | The counter logic is inverted: it increments on non-'(' characters and decrements only on ')', so it mis-tracks nesting depth. This causes incorrect grouping for valid inputs (e.g., '()()' produces a single group '()()' instead of ['()', '()']), so the implementation does not meet the specification. | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | false | 1 | 0 | The implementation does not correctly separate the groups of parentheses. It increments the counter when it encounters a character that is not an open parenthesis, which is incorrect. It should only increment the counter when it encounters an open parenthesis and decrement it when it encounters a close parenthesis. Als... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | false | 1 | 0 | The implementation does not correctly separate the groups of parentheses. It increments the counter when it encounters a character that is not an open parenthesis, which is incorrect. It should only increment the counter when it encounters an open parenthesis and decrement it when it encounters a close parenthesis. Als... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | false | 1 | 0 | The implementation does not correctly handle the case when the input string contains an opening parenthesis. The line 'if ch != '(': cnt += 1' is incorrect and should be 'if ch == '(': cnt += 1'. This is because the counter should be incremented when an opening parenthesis is encountered, not when any character other t... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | false | 0 | 0 | The implementation has a critical logical error: it increments `cnt` when encountering any character that is not '(', including ')'. This means that for every non-'(' character (including ')'), it increases the counter, and only decreases it when it sees ')'. This completely inverts the intended logic of tracking balan... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | false | 0 | 0 | The implementation has a critical logical error: it increments cnt when ch is not '(', but cnt should only be incremented when encountering '('. This causes the counter to increase incorrectly for any non-'(' character (including ')', letters, or spaces), leading to incorrect balancing. For example, in the input '( )',... | json_schema |
HumanEval/1 | mut_compare | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace ... | Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace is properly closed) and not nested within each other
Ignore any spaces in the input str... | false | Eq->NotEq | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | false | 0 | 0 | The implementation has a critical logical error: it increments cnt when ch is not '(', which is incorrect. The counter should only be incremented when encountering '(', and decremented when encountering ')'. This causes the counter to behave incorrectly, leading to wrong group separation. For example, in the input '( )... | json_schema |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.