Datasets:
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/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | true | 95 | 5 | The implementation correctly identifies pairs of numbers closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both provided t... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | true | 95 | 5 | The implementation correctly identifies pairs of numbers closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both provided t... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | true | 95 | 5 | The implementation correctly identifies pairs of numbers closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both provided t... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is the minimal necessary comparison to find any pair closer than the threshold, satisfying all given examples and the general specification. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is sufficient to find any pair closer than the threshold, satisfying the given examples and specification. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is sufficient to find any pair closer than the threshold, as the minimum difference between any two numbers must be between some consecutive elements in sorted order. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | true | 96 | 5 | The function correctly checks adjacent differences in the sorted list, which is sufficient to detect any pair of numbers closer than the threshold; it matches the examples and handles all valid inputs as specified. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | true | 96 | 5 | The function correctly checks all adjacent differences after sorting, and since the minimal distance between any two numbers is among adjacent sorted elements, this detects whether any pair is closer than the threshold. It matches the provided examples and the intended mathematical behavior for all float inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | true | 95 | 5 | The function correctly checks all adjacent pairs in the sorted list and returns True iff any pair has a difference smaller than the threshold; this matches the examples and the intended meaning of “closer than given threshold.” | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It first sorts the list of numbers, then iterates over the sorted list to check the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the threshold, ... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It first sorts the list of numbers, then iterates over the sorted list to check the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the threshold, ... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It first sorts the list of numbers, then iterates over the sorted list, checking the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the threshold,... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the docstring are correctly handled: [1.0, 2.0, 3.0] with thr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the docstring are correctly handled: [1.0, 2.0, 3.0] with thr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the docstring are correctly handled: [1.0, 2.0, 3.0] with thr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 0 | true | 95 | 5 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both pr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 1 | true | 95 | 5 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both pr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 2 | true | 95 | 5 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers must occur between consecutive elements in a sorted list, this approach is both correct and efficient (O(n log n)). Both pr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 0 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, returning True if any difference is less than the threshold, which matches the specification's examples and logic for all valid inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 1 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, returning True if any difference is less than the threshold, which matches the specification's examples and logic for all valid inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 2 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, returning True if any difference is less than the threshold, which matches the specification's examples and logic for all valid inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 0 | true | 95 | 5 | The function sorts the list and checks consecutive differences, which correctly detects whether any pair of numbers is closer than the given threshold; this matches the examples and the intended specification for all inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 1 | true | 96 | 5 | The function sorts the numbers and checks differences only between adjacent elements, which is sufficient to detect any pair closer than the threshold. It returns False for the first example and True for the second, matching the specification and intended behavior for all inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 2 | true | 97 | 5 | The function sorts the list and checks the differences between adjacent elements, correctly detecting whether any pair of numbers is closer than the given threshold; it matches the examples and intended behavior for all inputs. | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 0 | true | 1 | 1 | The implementation sorts the list of numbers and then checks each pair of adjacent numbers in the sorted list. If it finds a pair with a difference less than the threshold, it immediately returns True. If it checks all pairs without finding such a pair, it returns False. This correctly implements the task specification... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 1 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It first sorts the list of numbers, then iterates over the sorted list, checking the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the threshold,... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 2 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It sorts the list of numbers and then iterates through the sorted list, checking the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the threshold,... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 0 | true | 0 | 0 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples match: [1.0, 2.0, 3.0] with threshold 0.5 has minimum difference 1.0 (>= ... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 1 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the docstring are correctly handled: [1.0, 2.0, 3.0] with thr... | json_schema |
HumanEval/0 | baseline | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 2 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the docstring are correctly handled: [1.0, 2.0, 3.0] with thr... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | false | 85 | 4 | The implementation checks if the difference is <= threshold, but the specification asks for numbers 'closer to each other than given threshold', which means strictly less than (<), not less than or equal to (<=). The first example has_close_elements([1.0, 2.0, 3.0], 0.5) returns False because no consecutive pair differ... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | false | 85 | 4 | The implementation checks if the difference is <= threshold, but the specification asks for numbers 'closer to each other than given threshold', which means strictly less than (<), not less than or equal to (<=). The first example has_close_elements([1.0, 2.0, 3.0], 0.5) returns False because no consecutive pair differ... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | false | 85 | 4 | The implementation checks if the difference is <= threshold, but the specification asks for numbers 'closer to each other than given threshold', which means strictly less than (<), not less than or equal to (<=). The first example has_close_elements([1.0, 2.0, 3.0], 0.5) returns False because no consecutive pair differ... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | true | 100 | 5 | The implementation correctly sorts the list and checks adjacent differences, which is sufficient to find any pair closer than the threshold, and it returns False for lists with fewer than two elements as required. | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | true | 95 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is an efficient and correct method to find any pair closer than the threshold. It also correctly handles edge cases like lists with fewer than two elements, returning False as specified. | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is an efficient and correct method to find any pair closer than the threshold, and it explicitly handles lists with fewer than two elements by returning False. | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 0 | false | 85 | 3 | The implementation uses a non-strict comparison (<= threshold), while the specification and examples require checking for pairs with distance strictly less than the threshold. For example, the docstring’s additional test has_close_elements([1.0, 2.0, 3.0], 1.0) should be False by the original task description but retur... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 1 | false | 92 | 3 | The implementation uses `<= threshold` for the difference, but the specification examples imply a strict comparison ("closer than"), i.e., difference must be `< threshold`. Thus it returns True in some cases (e.g., difference exactly equal to threshold) where the spec would require False. | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 94 | 3 | The core algorithm of checking adjacent differences in the sorted list is sound, but it uses '<= threshold' while the spec/demo implies 'strictly less than threshold'; for example, it would return True for [1.0, 2.0, 3.0] with threshold 1.0, which conflicts with the intended behavior of 'closer than' the threshold. | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It sorts the list first, then iterates over the sorted list to check the difference between adjacent numbers. If it finds a pair of numbers with a difference less than or equal to the threshold, i... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It sorts the list first, then iterates over the sorted list to check the difference between adjacent numbers. If it finds a pair of numbers with a difference less than or equal to the threshold, i... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It sorts the list first, then iterates over the sorted list to check the difference between adjacent numbers. If it finds a pair of numbers with a difference less than or equal to the threshold, i... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than or equal to the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the specification are satisfied: [1.0, 2.0, 3.0] ... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences less than or equal to the threshold. This approach is valid because if any two numbers are closer than the threshold, they will be adjacent in the sorted list. The examples provided in the specification are satisfied: [1.0, 2.0, 3.0] ... | json_schema |
HumanEval/0 | consistent_bug_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
"""Check if in the given list of numbers, any two numbers have a difference less than or equal to the given threshold.
Returns True if there exists at least one pair of numbers whose difference is less than or equal to... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | mut_compare | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | true | 1 | 1 | The implementation correctly sorts the list and checks adjacent pairs for differences <= threshold. This is optimal because if any two elements are within threshold, the closest such pair must be adjacent in the sorted order. The examples match: [1.0,2.0,3.0] with threshold 0.5 has min difference 1.0 > 0.5 -> False; [1... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers occurs between consecutive elements in a sorted list, this approach is both correct and efficient. The obfuscated variable ... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers occurs between consecutive elements in a sorted list, this approach is both correct and efficient. The obfuscated variable ... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting the list and checking consecutive elements. Since the minimum distance between any two numbers occurs between consecutive elements in a sorted list, this approach is both correct and efficient. The obfuscated variable ... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | false | 95 | 2 | The implementation incorrectly compares only consecutive elements after sorting, but the specification requires checking any two numbers, not just adjacent ones. For example, in the list [1.0, 2.0, 3.0] with threshold 1.5, the distance between 1.0 and 3.0 is 2.0, which is not less than 1.5, but the distance between 1.0... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | false | 95 | 2 | The implementation incorrectly compares only consecutive elements after sorting, but the specification requires checking any two numbers, not just adjacent ones. For example, in the list [1.0, 2.0, 3.0] with threshold 1.5, the distance between 1.0 and 3.0 is 2.0 which is not less than 1.5, but the distance between 1.0 ... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 90 | 2 | The implementation only checks consecutive elements after sorting, which fails to detect close elements that are not adjacent in the sorted list, such as when the threshold is large enough to span multiple elements. | json_object |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | true | 96 | 4 | The function correctly sorts the list and checks adjacent differences; if any difference is less than the threshold it returns True, otherwise False. This matches the specification and provided examples for all float inputs, though the obfuscated variable names slightly reduce code clarity, not correctness. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | true | 95 | 4 | The function correctly checks all adjacent pairs in the sorted list and returns True if any difference is less than the threshold, which is equivalent to checking all pairs. It matches the provided examples and the intended behavior; minor variable name oddities do not affect correctness. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | true | 96 | 5 | The function sorts the numbers and checks adjacent differences, returning True if any pair is closer than the threshold, which matches the specification and examples for all float inputs. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 100 | 5 | The implementation correctly checks for any two numbers closer to each other than the given threshold by sorting the list and comparing adjacent elements. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | true | 100 | 5 | The implementation correctly checks for any two numbers closer to each other than the given threshold by sorting the list and comparing adjacent elements. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | true | 1 | 1 | The implementation correctly checks if any two numbers in the list are closer to each other than the given threshold by sorting the list and then iterating through it to find any pairs of numbers with a difference less than the threshold. | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | true | 1 | 1 | The implementation correctly sorts the list of numbers and then checks adjacent pairs for differences less than the threshold. Since the list is sorted, the closest pairs must be adjacent, so checking only adjacent pairs is sufficient. The variables _k0 and _k1 are both set to 1, which effectively makes the code compar... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | true | 1 | 1 | The implementation correctly sorts the list of numbers and then checks adjacent pairs for differences less than the threshold. Since the list is sorted, the closest pairs must be adjacent, so checking only adjacent pairs is sufficient. The use of _k0 and _k1 as 1 is redundant but harmless. The function returns True if ... | json_schema |
HumanEval/0 | extract_constants | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | true | 1 | 1 | The implementation correctly sorts the list of numbers and then checks adjacent pairs for any difference less than the threshold. This is an efficient and correct approach because if any two numbers are closer than the threshold, they must be adjacent in the sorted list (otherwise, there would be a number between them ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting and checking consecutive elements. The docstring examples differ from the specification examples, but the actual algorithm is sound and handles both test cases correctly: [1.0, 2.0, 3.0] with threshold 0.5 returns Fals... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting and checking consecutive elements. The docstring examples differ from the specification examples, but the actual algorithm is sound and handles both test cases correctly: [1.0, 2.0, 3.0] with threshold 0.5 returns Fals... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | true | 95 | 4 | The implementation correctly identifies when any two numbers are closer than the threshold by sorting and checking consecutive elements. The docstring examples differ from the specification examples, but the actual algorithm is sound and handles both test cases correctly: [1.0, 2.0, 3.0] with threshold 0.5 returns Fals... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | false | 100 | 2 | The implementation's docstring incorrectly states it checks if 'all pairs' are closer, but the specification requires checking if 'any two numbers' are closer. The implementation's logic is correct for the specification, but its docstring examples are wrong: the first example should return True (as it does) but the sec... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | false | 95 | 2 | The implementation's docstring incorrectly states it checks if all pairs are closer than the threshold, but the specification requires checking if any two numbers are closer. The implementation's logic is correct for the specification, but the docstring examples are wrong: the first example should return True (since 1.... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | false | 100 | 2 | The implementation's docstring incorrectly states it checks if 'all pairs' are closer, but the specification requires checking if 'any two numbers' are closer. The implementation's logic is correct for the specification, but its provided example outputs are reversed compared to the specification's examples, indicating ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 0 | true | 90 | 4 | The function’s behavior matches the task specification and examples: it correctly returns True if any pair of numbers is closer than the threshold by checking adjacent differences after sorting. The docstring text is misleading, but that does not affect runtime behavior, which satisfies the given specification. | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 1 | true | 84 | 4 | The implementation correctly returns True if there exists at least one pair of numbers with a difference smaller than the threshold by checking adjacent elements in the sorted list; this matches the task specification and examples, despite the docstring text being incorrect. Runtime behavior for all valid inputs satisf... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 100 | 4 | The implementation correctly checks whether there exists at least one pair of numbers closer than the threshold, matching the task specification and examples, but the docstring description and its doctests are inconsistent with the intended behavior. Runtime behavior, however, is correct for the specified task. | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | false | 1 | 0 | The implementation does not satisfy the specification because it returns True when it finds a pair of numbers closer than the threshold, whereas the specification requires it to return True when it finds a pair of numbers closer to each other than the threshold. The implementation's docstring also contradicts the task ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 1 | false | 1 | 1 | The implementation does not satisfy the specification. The task specification asks to check if any two numbers are closer to each other than the given threshold, but the implementation checks if all pairs of adjacent numbers in the sorted list are closer to each other than the threshold. The implementation returns True... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 2 | false | 1 | 0 | The implementation does not satisfy the specification. The specification states that the function should return True if any two numbers are closer to each other than the given threshold, but the implementation returns True if any two adjacent numbers in the sorted list are closer than the threshold. The implementation ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 0 | false | 1 | 0 | The implementation has a logical error in its docstring and comment: it claims to check 'if all pairs of numbers are closer to each other than the threshold', but the actual code checks if any pair is closer than the threshold — which matches the task specification. However, the docstring examples are incorrect: the fi... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 1 | false | 1 | 0 | The implementation has a logical error in its docstring and comment, which incorrectly state 'Check if all pairs of numbers... are closer', while the actual specification requires checking if 'any two numbers are closer than the threshold'. Although the function logic correctly returns True if any adjacent pair in the ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | default | 2 | false | 1 | 1 | The implementation has the correct logic for checking if any two numbers are closer than the threshold by sorting and comparing adjacent elements. However, the docstring and example assertions in the implementation are incorrect. The specification requires returning True if any two numbers are closer than the threshold... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 0 | true | 95 | 4 | The implementation correctly identifies if any two numbers are closer than the threshold by sorting and checking consecutive elements. This is an efficient approach since if any pair is closer than the threshold, at least one pair of consecutive elements in the sorted list must also be closer than the threshold. The do... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 1 | true | 95 | 4 | The implementation correctly identifies if any two numbers are closer than the threshold by sorting and checking consecutive elements. This is an efficient approach since if any pair is closer than the threshold, at least one pair of consecutive elements in the sorted list must also be closer than the threshold. The do... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | claude | anthropic/claude-haiku-4.5 | ignore_docs | 2 | true | 95 | 4 | The implementation correctly identifies if any two numbers are closer than the threshold by sorting and checking consecutive elements. This is an efficient approach since if any pair is closer than the threshold, at least one pair of consecutive elements in the sorted list must also be closer than the threshold. The do... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 0 | false | 100 | 2 | The implementation's docstring incorrectly states it checks if 'all pairs' are closer, but the code correctly checks if any pair is closer. However, the implementation fails the second provided example: has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3) returns False, but the specification requires True because 2.... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 1 | false | 100 | 2 | The implementation incorrectly returns True when any pair is closer than the threshold, but the specification's docstring examples show it should return False for the first case and True for the second, which the candidate's own docstrings contradict. The actual code logic matches the specification's requirement to det... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | ignore_docs | 2 | false | 100 | 2 | The implementation incorrectly returns True when any pair is closer than the threshold, but the specification's docstring says to check if 'any two numbers' are closer, which the code does correctly; however, the candidate's own docstring contradicts the specification and the provided examples, and the code's behavior ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 0 | true | 96 | 5 | The function correctly returns True if there exists at least one pair of numbers whose distance is less than the threshold, and False otherwise. Its behavior matches the stated specification and the provided examples, despite the misleading docstring text. | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 1 | true | 100 | 5 | The implementation returns True iff there exists at least one pair of numbers with difference less than the threshold, matching the specification and example behaviors; the misleading docstring contradicts the task but is not executed and does not affect runtime behavior. | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | gpt | openai/gpt-5.1 | ignore_docs | 2 | true | 96 | 5 | The function correctly checks whether there exists at least one pair of numbers closer than the threshold by sorting the list and comparing adjacent differences. This matches the specification examples and intended behavior; the misleading docstring does not affect runtime behavior. | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 0 | false | 1 | 0 | The implementation returns True when it finds two numbers closer to each other than the threshold, but the docstring in the task specification indicates that the function should return True if there are any two numbers closer to each other than the given threshold. However, the implementation is actually correct accord... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 1 | true | 1 | 1 | The candidate implementation sorts the list of numbers and then checks each pair of adjacent numbers in the sorted list. If it finds a pair with a difference less than the threshold, it immediately returns True. If it checks all pairs without finding such a pair, it returns False. This is a correct implementation of th... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | ignore_docs | 2 | true | 1 | 1 | The candidate implementation correctly checks if any two numbers in the given list are closer to each other than the given threshold. It sorts the list of numbers and then iterates over the sorted list, checking the difference between each pair of adjacent numbers. If it finds a pair with a difference less than the thr... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 0 | false | 1 | 0 | The implementation correctly checks if any two adjacent numbers in the sorted list are closer than the threshold, which is a valid approach. However, the docstring incorrectly states that the function checks 'if all pairs of numbers... are closer', which contradicts both the specification and the actual behavior. More ... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 1 | false | 1 | 0 | The implementation has the correct logic for checking if any two adjacent numbers in the sorted list are closer than the threshold — which is an efficient and valid approach. However, the docstring and example test cases in the implementation are incorrect. The specification requires returning True if any two numbers a... | json_schema |
HumanEval/0 | misleading_doc | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if all pairs of numbers in the given list are closer to each other than
given threshold.
>>> has_close_elements([1.0, 1.2, 1.1], 0.5)
True
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0],... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| true | null | null | null | null | qwen | qwen/qwen3-next-80b-a3b-instruct | ignore_docs | 2 | false | 100 | 3 | The implementation correctly checks for any two adjacent numbers in the sorted list being closer than the threshold, but the docstring incorrectly claims it checks 'all pairs' and provides wrong expected outputs, contradicting the task specification which requires detecting if any pair is closer than the threshold. | json_object |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 0 | false | 85 | 4 | The implementation uses <= instead of < for the threshold comparison. According to the specification, numbers should be 'closer to each other than given threshold', which means the distance should be strictly less than the threshold, not less than or equal to. For example, if two numbers are exactly at the threshold di... | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 1 | false | 85 | 4 | The implementation uses <= instead of < for the threshold comparison. According to the specification, numbers should be 'closer to each other than given threshold', which means the distance should be strictly less than the threshold, not less than or equal to. For example, if two numbers are exactly at the threshold di... | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | claude | anthropic/claude-haiku-4.5 | default | 2 | false | 85 | 4 | The implementation uses <= instead of < for the threshold comparison. According to the specification, numbers should be 'closer to each other than given threshold', which means the distance should be strictly less than the threshold, not less than or equal to. For example, if two numbers are exactly at the threshold di... | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 0 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is sufficient to find any pair closer than the threshold, satisfying the given examples and specification. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 1 | true | 95 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is efficient and matches the specification's examples and general requirement for any two numbers being closer than the threshold. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | deepseek | deepseek/deepseek-v3.2-exp | default | 2 | true | 100 | 5 | The implementation correctly sorts the list and checks consecutive differences, which is sufficient to find any pair closer than the threshold, as the minimum distance between any two numbers must be between some consecutive elements in sorted order. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | gpt | openai/gpt-5.1 | default | 0 | false | 90 | 3 | The specification says to check whether any two numbers are *closer* than the threshold, but the implementation uses "<= threshold" instead of "< threshold", so it incorrectly returns True when two numbers differ by exactly the threshold. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | gpt | openai/gpt-5.1 | default | 1 | false | 90 | 3 | The implementation uses `<= threshold` instead of strictly `< threshold`, so it treats pairs at exactly the threshold distance as "closer" than the threshold, which does not match the usual reading of the specification; otherwise logic is sound. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | gpt | openai/gpt-5.1 | default | 2 | false | 96 | 3 | The implementation treats pairs with distance equal to the threshold as 'close' (<= threshold), while the specification says 'closer than' the threshold, which implies a strict inequality (< threshold). For inputs where the minimum distance equals the threshold, it will incorrectly return True instead of False. | json_schema |
HumanEval/0 | mut_compare | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2... | Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, 2.0], 0.3)
True
| false | Lt->LtE | null | null | null | llama | meta-llama/llama-3.3-70b-instruct | default | 0 | true | 1 | 1 | The implementation correctly checks for any two numbers in the list that are closer to each other than the given threshold. It sorts the list first, then iterates over the sorted list to check the difference between adjacent numbers. If it finds a pair of numbers with a difference less than or equal to the threshold, i... | json_schema |
End of preview. Expand in Data Studio
Judges Blame the Code
Judge verdicts on oracle-verified perturbations of Python programs, from the paper When the Docstring Lies, LLM Judges Blame the Code.
Every candidate program was executed against the canonical solution before any judge saw it, so each row carries both what the judge said and what is actually true. That makes the data usable as a labelled benchmark rather than only as a record of one experiment.
Configs
| Config | Source | Problems | Variants | Rows |
|---|---|---|---|---|
HumanEvalP |
HumanEval+ | 161 | 1,453 | 28,373 |
LiveCodeBenchV6 |
LiveCodeBench, v4 to v6 increments | 157 | 1,492 | 22,377 |
from datasets import load_dataset
he = load_dataset("JudgeOfJudges/judges_blame_the_code", "HumanEvalP", split="train")
lcb = load_dataset("JudgeOfJudges/judges_blame_the_code", "LiveCodeBenchV6", split="train")
One row is one judge verdict, so a single program variant appears once per (judge, repetition). Five judges times three repetitions gives fifteen rows per variant.
Columns
| Column | Description |
|---|---|
task_id |
problem id, HumanEval/N or LCB/N |
condition |
which perturbation, see the table below |
entry_point |
name of the function under test |
code |
the candidate program shown to the judge |
spec |
task specification shown to the judge, byte-identical across conditions for a given problem |
oracle_pass |
ground truth from execution: does this code agree with the canonical solution on every test input |
mutation_site |
where the single-token bug was injected, e.g. Lt->LtE or int+1. Null unless the code contains an injected bug, so this is null for baseline, the four preserving conditions, and misleading_doc |
mutation_from |
which mutant family consistent_bug_doc was built from. Null for every other condition, including the mutants themselves, where it would only repeat condition |
difficulty |
LiveCodeBench only |
contest_date |
LiveCodeBench only, enables recency analysis |
judge |
short judge name |
judge_model |
full model id as served |
prompt_variant |
default, or ignore_docs for the instruction control |
rep |
repetition index, 0 to 2 |
said_correct |
the judge's verdict |
confidence |
judge self-reported confidence, 0 to 100 |
quality |
judge quality rating, 1 to 5 |
reason |
the judge's one-sentence justification |
json_mode |
how the verdict was obtained: json_schema, json_object, or prompt extraction |
said_correct == oracle_pass gives per-row accuracy.
mutation_site and mutation_from are null wherever there is nothing to
record: a condition that injects no bug has no site, and only
consistent_bug_doc is built on top of another condition. Nothing is missing,
so mutation_site.notna() selects exactly the rows whose code contains an
injected bug.
Conditions
Every variant is built from one normalized baseline per problem,
ast.unparse(ast.parse(original)), so any two conditions differ by exactly one
intended edit and no incidental formatting.
| Condition | Edit | oracle_pass |
|---|---|---|
baseline |
none | true |
rename |
identifiers become v0, v1, ... |
true |
strip_docstring |
docstring removed | true |
reformat |
indentation and blank lines | true |
extract_constants |
literals hoisted to named locals | true |
mut_compare |
comparison operator flipped | false |
mut_offbyone |
integer literal shifted by 1 | false |
mut_swap |
operand or argument order swapped | false |
misleading_doc |
correct code, docstring describes different behaviour | true |
consistent_bug_doc |
buggy code, docstring describes the bug | false |
A variant is included only if execution agrees with the oracle_pass its
condition declares. Preserving transforms that changed behaviour and mutants
that turned out to be equivalent were dropped rather than kept.
Judges
Qwen3-Next-80B, DeepSeek-V3.2 and Llama-3.3-70B as open-weight judges, Claude Haiku 4.5 and GPT-5.1 as frontier judges. All five ran at temperature 0 through a single OpenAI-compatible endpoint, so the model is the only thing that varies between arms. 87.1% of verdicts were schema-constrained.
The instruction control
HumanEvalP contains 6,584 rows with prompt_variant == "ignore_docs", on the
baseline, misleading_doc and mut_compare conditions. These use a system
prompt stating that docstrings are unreliable, are not part of the
specification, and should be disregarded. Filter to prompt_variant == "default" for the main arm.
Notes
The adversarial docstrings in misleading_doc and consistent_bug_doc are
model-generated. They are the only part of the dataset not verified by
execution: the oracle can confirm the code still passes or still fails, but not
that a docstring is convincingly misleading.
LiveCodeBench reference solutions are model-generated and execution-verified against every public and private test. HumanEval+ canonical solutions are the human-written originals.
LiveCodeBenchV6 draws on the v4, v5 and v6 increments of the LiveCodeBench
release, covering contests up to 2025-04-06.
Derived from HumanEval+ (MIT) and LiveCodeBench (CC BY 4.0). Please cite both upstream datasets alongside this one.
- Downloads last month
- 25