task_id stringlengths 11 13 | prompt stringlengths 141 1.4k | entry_point stringlengths 3 31 | canonical_solution stringlengths 24 865 | test stringlengths 117 1.8k | contract stringlengths 63 844 | base_input stringlengths 16 2.08k | plus_input stringlengths 12 199k | atol float64 0 0 | original_prompt stringlengths 115 1.36k | original_entry_point stringlengths 1 30 | rename_map stringlengths 30 98 |
|---|---|---|---|---|---|---|---|---|---|---|---|
HumanEval/0 | from typing import List
def yakin_iki_sayi_var_mi(sayilar: List[float], esik_deger: float) -> bool:
""" Verilen sayi listesinde, verilen esik degerden birbirine daha yakin olan herhangi iki sayi olup olmadigini kontrol edin.
>>> yakin_iki_sayi_var_mi([1.0, 2.0, 3.0], 0.5)
False
>>> yakin_iki_sayi_var_... | yakin_iki_sayi_var_mi |
sorted_numbers = sorted(sayilar)
for i in range(len(sorted_numbers) - 1):
if sorted_numbers[i + 1] - sorted_numbers[i] < esik_deger:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True
assert candidate([1.0, 2.0, 5.9, 4.0,... |
assert isinstance(esik_deger, float) and esik_deger > 0, "invalid inputs" # $_CONTRACT_$
assert isinstance(sayilar, list), "invalid inputs" # $_CONTRACT_$
assert all([isinstance(v, (int, float)) for v in sayilar]), "invalid inputs" # $_CONTRACT_$
| [[[1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3], [[1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05], [[1.0, 2.0, 5.9, 4.0, 5.0], 0.95], [[1.0, 2.0, 5.9, 4.0, 5.0], 0.8], [[1.0, 2.0, 3.0, 4.0, 5.0, 2.0], 0.1], [[1.1, 2.2, 3.1, 4.1, 5.1], 1.0], [[1.1, 2.2, 3.1, 4.1, 5.1], 0.5]] | [[[1.0, 2.5, 3.0, 4.5, 5.0, 6.5], 0.4], [[1.0, 2.0, 3.0, 2.9, 5.0, 6.0], 0.1], [[0.5, 0.6, 0.7, 0.8, 0.9], 0.05], [[10.5, 20.5, 30.5, 25.5, 40.5], 4.0], [[1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7], 0.2], [[0.1, 0.5, 1.0, 1.5, 2.0], 0.1], [[1.2, 2.4, 3.6, 4.8], 0.8], [[-1.0, -0.5, 0.0, 0.5, 1.0], 0.3], [[-2.0, 2.0, 3.0, 4.0], ... | 0 | 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, ... | has_close_elements | {"has_close_elements": "yakin_iki_sayi_var_mi", "numbers": "sayilar", "threshold": "esik_deger"} |
HumanEval/1 | from typing import List
def ayir_parantez_gruplari(parantez_metni: str) -> List[str]:
""" Input bu fonksiyona icinde birden fazla parantez grubu iceren bir dizgi verir. Amaciniz
bu gruplari ayri dizgilere ayirmak ve bu dizgilerin listesini donmektir.
Ayri gruplar dengelidir (her acilma parantezi uygun sek... | ayir_parantez_gruplari |
cnt, group, results = 0, "", []
for ch in parantez_metni:
if ch == "(": cnt += 1
if ch == ")": cnt -= 1
if ch != " ": group += ch
if cnt == 0:
if group != "": results.append(group)
group = ""
return results
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [
'(()())', '((()))', '()', '((())()())'
]
assert candidate('() (()) ((())) (((())))') == [
'()', '(())', '((()))', '(((())))'
]
assert candidate('(()... |
assert type(parantez_metni) == str, "invalid inputs" # $_CONTRACT_$
cnt = 0 # $_CONTRACT_$
for ch in parantez_metni: # $_CONTRACT_$
assert ch in ["(", ")", " "], "invalid inputs" # $_CONTRACT_$
if ch == "(": cnt += 1 # $_CONTRACT_$
if ch == ")": cnt -= 1 # $_CONTRACT_$
asse... | [["(()()) ((())) () ((())()())"], ["() (()) ((())) (((())))"], ["(()(())((())))"], ["( ) (( )) (( )( ))"]] | [["()"], ["(())"], ["((()))()"], ["()()()"], ["()(()())()"], ["(((()()((())))))"], ["((()()))(())"], ["()(()()((())))"], ["()()()(((()())))()(())"], ["(((())))()((()()))"], ["(((())))()(((())))()((()()))((()()))"], ["((((((())))()(((())))()((()()))((()())))()))(())"], ["()(()())()(()()((())))()"], ["()(()()((()))(((()(... | 0 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace... | separate_paren_groups | {"separate_paren_groups": "ayir_parantez_gruplari", "paren_string": "parantez_metni"} |
HumanEval/2 | def ondalik_bolum(sayi: float) -> float:
""" Pozitif bir kayan nokta sayi verildiginde, bu sayi
tam bir bolum (verilen sayidan kucuk en buyuk tam sayi) ve ondalik kisimlarina
(her zaman 1'den kucuk kalan kisim) ayrilabilir.
Sayinin ondalik kismini dondurun.
>>> ondalik_bolum(3.5)
0.5
"""
| ondalik_bolum |
return sayi - int(sayi)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3.5) == 0.5
assert abs(candidate(1.33) - 0.33) < 1e-6
assert abs(candidate(123.456) - 0.456) < 1e-6
|
assert sayi > 0, "invalid inputs" # $_CONTRACT_$
assert isinstance(sayi, float), "invalid inputs" # $_CONTRACT_$
assert sayi != float("+inf"), "invalid inputs" # $_CONTRACT_$
| [[3.5], [1.33], [123.456]] | [[999.99999], [0.3333333], [1.0], [1.5], [0.5], [0.999999], [500.00678], [11.11], [0.25], [5.99], [1.284163165748358], [1.8517611088029418], [0.7713842427275083], [3.1842364304976463], [1.0738831860229472], [0.04320870526393539], [1.1369261836552624], [1.0630407193724771], [10.291122396192739], [1.7558893686701653], [0... | 0.000001 |
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0... | truncate_number | {"truncate_number": "ondalik_bolum", "number": "sayi"} |
HumanEval/3 | from typing import List
def sifir_altti(islemler: List[int]) -> bool:
""" Sifir bakiye ile baslayan bir banka hesabina yapilan para yatirma ve para cekme islemlerinin listesini alirsiniz. Goreviniz, herhangi bir anda hesap bakiyesinin sifir altina dusup dusmedigini tespit etmektir. Bakiye sifir altina dusuldugund... | sifir_altti |
account = 0
for operation in islemler:
account += operation
if account < 0:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == False
assert candidate([1, 2, -3, 1, 2, -3]) == False
assert candidate([1, 2, -4, 5, 6]) == True
assert candidate([1, -1, 2, -2, 5, -5, 4, -4]) == False
assert candidate([1, -1, 2, -2, 5, -5, 4... |
assert type(islemler) == list, "invalid inputs" # $_CONTRACT_$
assert all([isinstance(v, int) for v in islemler]), "invalid inputs" # $_CONTRACT_$
| [[[]], [[1, 2, -3, 1, 2, -3]], [[1, 2, -4, 5, 6]], [[1, -1, 2, -2, 5, -5, 4, -4]], [[1, -1, 2, -2, 5, -5, 4, -5]], [[1, -2, 2, -2, 5, -5, 4, -4]]] | [[[0]], [[0, 0, 0, 0]], [[1, 2, 3, -6]], [[-1, -2, -3, 6]], [[1, 2, 3, 4, -10, 5, 6, -15]], [[10, -20, 30, -40, 50, -60]], [[5, -10, 15, -20, 25, -30, 35, -40, 45, -50]], [[1, -1, 1, -1, 1, -1, 1, -1, 1, -1]], [[10, -15, 20, -25, 30, -35, 40, -45]], [[1, -2, 3, -4, 5, -6, 7, -8, 9, -10]], [[15, 2, 3, -6]], [[-1, -3, 6]... | 0 | from typing import List
def below_zero(operations: List[int]) -> bool:
""" You're given a list of deposit and withdrawal operations on a bank account that starts with
zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
at that point function should return Tru... | below_zero | {"below_zero": "sifir_altti", "operations": "islemler"} |
HumanEval/4 | "from typing import List\n\n\ndef ortalama_mutlak_sapma(sayilar: List[float]) -> float:\n \"\"\" (...TRUNCATED) | ortalama_mutlak_sapma | "\n mean = sum(sayilar) / len(sayilar)\n return sum(abs(x - mean) for x in sayilar) / len(sayi(...TRUNCATED) | "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) | "\n assert all(isinstance(x, float) for x in sayilar), \"invalid inputs\" # $_CONTRACT_$\n ass(...TRUNCATED) | [[[1.0, 2.0, 3.0]], [[1.0, 2.0, 3.0, 4.0]], [[1.0, 2.0, 3.0, 4.0, 5.0]]] | "[[[-1.0, 4.5, 0.0, 2.5, -3.0]], [[0.0, 0.0, 0.0, 0.0, 0.0]], [[-2.0, 2.0]], [[-1.0, -1.0, 1.0, 1.0](...TRUNCATED) | 0.000001 | "from typing import List\n\n\ndef mean_absolute_deviation(numbers: List[float]) -> float:\n \"\"\(...TRUNCATED) | mean_absolute_deviation | {"mean_absolute_deviation": "ortalama_mutlak_sapma", "numbers": "sayilar"} |
HumanEval/5 | "from typing import List\n\n\ndef aralarina_ekle(sayilar: List[int], ayirac: int) -> List[int]:\n (...TRUNCATED) | aralarina_ekle | "\n\n res = []\n for i in range(len(sayilar)):\n res.append(sayilar[i])\n if i !(...TRUNCATED) | "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) | "\n assert all([isinstance(v, int) for v in sayilar]), \"invalid inputs\" # $_CONTRACT_$\n ass(...TRUNCATED) | [[[], 7], [[5, 6, 3, 2], 8], [[2, 2, 2], 2]] | "[[[1, 2, 3], 0], [[2, 4, 6, 8], 1], [[9, 9, 9, 9, 9, 9], 7], [[10], 5], [[5, 7], 2], [[1, 3, 5, 7],(...TRUNCATED) | 0 | "from typing import List\n\n\ndef intersperse(numbers: List[int], delimeter: int) -> List[int]:\n (...TRUNCATED) | intersperse | {"intersperse": "aralarina_ekle", "numbers": "sayilar", "delimeter": "ayirac"} |
HumanEval/6 | "from typing import List\n\n\ndef parantez_derinliklerini_bul(parantez_dizisi: str) -> List[int]:\n (...TRUNCATED) | parantez_derinliklerini_bul | "\n \n def count_depth(s: str) -> int:\n max_depth, cnt = 0, 0\n for ch in s:\n (...TRUNCATED) | "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) | "\n assert type(parantez_dizisi) == str, \"invalid inputs\" # $_CONTRACT_$\n cnt = 0 # $_CONTR(...TRUNCATED) | [["(()()) ((())) () ((())()())"], ["() (()) ((())) (((())))"], ["(()(())((())))"]] | "[[\"\"], [\"((()))\"], [\"(())(()())\"], [\"(())(()(()))((()()))\"], [\"(()()(((())))(()(())))()\"](...TRUNCATED) | 0 | "from typing import List\n\n\ndef parse_nested_parens(paren_string: str) -> List[int]:\n \"\"\" I(...TRUNCATED) | parse_nested_parens | {"parse_nested_parens": "parantez_derinliklerini_bul", "paren_string": "parantez_dizisi"} |
HumanEval/7 | "from typing import List\n\n\ndef alt_dizeye_gore_filtrele(dizeler: List[str], alt_dize: str) -> Lis(...TRUNCATED) | alt_dizeye_gore_filtrele |
return list(filter(lambda s: alt_dize in s, dizeler))
| "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) | "\n assert type(dizeler) == list, \"invalid inputs\" # $_CONTRACT_$\n assert all(type(x) == st(...TRUNCATED) | "[[[], \"john\"], [[\"xxx\", \"asd\", \"xxy\", \"john doe\", \"xxxAAA\", \"xxx\"], \"xxx\"], [[\"xxx(...TRUNCATED) | "[[[\"banana\", \"apple\", \"kiwi\", \"peach\"], \"a\"], [[\"hello\", \"world\", \"python\", \"numpy(...TRUNCATED) | 0 | "from typing import List\n\n\ndef filter_by_substring(strings: List[str], substring: str) -> List[st(...TRUNCATED) | filter_by_substring | "{\"filter_by_substring\": \"alt_dizeye_gore_filtrele\", \"strings\": \"dizeler\", \"substring\": \"(...TRUNCATED) |
HumanEval/8 | "from typing import List, Tuple\n\n\ndef toplam_carpim(sayilar: List[int]) -> Tuple[int, int]:\n (...TRUNCATED) | toplam_carpim | "\n s, p = 0, 1\n for number in sayilar:\n s += number\n p *= number\n return(...TRUNCATED) | "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) |
assert all([isinstance(v, int) for v in sayilar]), "invalid inputs" # $_CONTRACT_$
| [[[]], [[1, 1, 1]], [[100, 0]], [[3, 5, 7]], [[10]]] | "[[[2, 4, 6, 8, 10]], [[0, 1, 2, 3, 4, 5]], [[-1, 1, -2, 2, -3, 3]], [[2, 3, 5, 7, 11, 13]], [[1, 2,(...TRUNCATED) | 0 | "from typing import List, Tuple\n\n\ndef sum_product(numbers: List[int]) -> Tuple[int, int]:\n \"(...TRUNCATED) | sum_product | {"sum_product": "toplam_carpim", "numbers": "sayilar"} |
HumanEval/9 | "from typing import List, Tuple\n\n\ndef akiskan_maks(sayilar: List[int]) -> List[int]:\n \"\"\" (...TRUNCATED) | akiskan_maks |
return [max(sayilar[:(i+1)]) for i in range(len(sayilar))]
| "\n\nMETADATA = {\n 'author': 'jt',\n 'dataset': 'test'\n}\n\n\ndef check(candidate):\n ass(...TRUNCATED) | "\n assert isinstance(sayilar, list), \"invalid inputs\" # $_CONTRACT_$\n assert all([isinstan(...TRUNCATED) | [[[]], [[1, 2, 3, 4]], [[4, 3, 2, 1]], [[3, 2, 3, 100, 3]]] | "[[[1, 1, 1, 1, 1]], [[5, 4, 3, 2, 1]], [[1, 3, 2, 4, 3, 5, 4, 6]], [[10, 5, 20, 30, 25, 20, 15, 10](...TRUNCATED) | 0 | "from typing import List, Tuple\n\n\ndef rolling_max(numbers: List[int]) -> List[int]:\n \"\"\" F(...TRUNCATED) | rolling_max | {"rolling_max": "akiskan_maks", "numbers": "sayilar"} |
End of preview. Expand in Data Studio
HumanEval+ TR
A full Turkish translation of HumanEval+ (EvalPlus v0.1.10), all 164 problems.
Most translated code benchmarks only translate the docstring. This one translates everything a model reads:
- docstrings and comments
- function names, parameter names and helper function names
- function names inside the docstring examples
Only ASCII letters are used (c g i o s u instead of ç ğ ı ö ş ü), so identifiers stay valid, conventional Python names.
String literals, numbers, type hints and expected example outputs are left exactly as in the original, so the tests still apply.
Example
Original:
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
"""
Translated:
def yakin_elemanlar_var_mi(sayilar: List[float], sinir: float) -> bool:
""" Verilen sayi listesinde, herhangi iki sayinin birbirine yakinligi verilen sinirdan daha kucuk olup olmadigini
kontrol edin.
>>> yakin_elemanlar_var_mi([1.0, 2.0, 3.0], 0.5)
False
"""
How it was made
- Machine translation with Qwen3.6-35B-A3B (Q4, thinking on) running locally through llama.cpp.
- Automatic checks on every problem: same functions in the same order, no function body added to the stub, the entry point actually renamed, and the old name gone.
- Verified against the tests. The canonical solution was renamed with the same mapping, then run against the original solution on every base and plus input. All 164 produce identical outputs. Problems that failed any check were re-translated.
- Human reviewed by a native Turkish speaker.
21 of 164 problems needed a second translation attempt. The scripts used are in scripts/, and every raw model attempt (including rejected ones) is in raw/translation_attempts.jsonl.
Format
Two files with the same rows:
humanevalplus_tr.jsonl: the canonical file. Same schema asHumanEvalPlus.jsonl, so it works with EvalPlus tooling (for example throughHUMANEVAL_OVERRIDE_PATH). This is the one BenchKit uses.viewer/test.jsonl: the same data for the Hub viewer anddatasets.load_dataset.base_input,plus_inputandrename_mapare stored as JSON strings, because their types differ from problem to problem. Usejson.loadsto get them back.
Columns (extra ones are for traceability):
| column | description |
|---|---|
task_id |
original id, e.g. HumanEval/0 |
prompt |
translated function stub |
entry_point |
translated function name |
canonical_solution |
original solution with parameters and helper calls renamed |
test, base_input, plus_input, atol |
unchanged from HumanEval+ |
contract |
input asserts, renamed to the new parameter names |
original_prompt, original_entry_point |
the English source |
rename_map |
English to Turkish name mapping used |
Usage
It is built into BenchKit as humaneval-plus-tr:
uv run benchkit --headless --models MODEL --benchmarks humaneval-plus-tr
Credits and license
Based on HumanEval (MIT, OpenAI) and HumanEval+ / EvalPlus (Apache-2.0). This translation is released under Apache-2.0.
Made by Doğukan Ürker.
- Downloads last month
- 36