prompt large_stringclasses 64
values | domain large_stringclasses 8
values | bug_type large_stringclasses 8
values | difficulty large_stringclasses 2
values | code_v1 large_stringlengths 28 64 | stdout_v1 large_stringclasses 2
values | stderr_v1 large_stringlengths 0 167 | repair_reasoning large_stringclasses 8
values | code_v2 large_stringlengths 129 153 | execution_output large_stringclasses 100
values | stderr_v2 large_stringclasses 1
value | repair_verified bool 1
class | runtime_ms float64 158 331 | traceback_chars int64 0 167 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Correct execution behavior and pass assertions. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | key_error | hard | def solve_0(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_0
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_0(x):
return x * 2 + 0
print(solve_0(10))
assert solve_0(10) == 20
assert solve_0(0) == 0
assert solve_0(5) == 10 | 20 | true | 172.12 | 131 | ||
Fix the algorithm and validate outputs. Domain: math. Repair the failing implementation and verify correctness. | math | assertion | hard | def solve_1(x):
return x*2
assert solve_1(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_1(x):
return x * 2 + 1
print(solve_1(10))
assert solve_1(10) == 21
assert solve_1(0) == 1
assert solve_1(5) == 11 | 21 | true | 173.51 | 88 | ||
Implement a verified arithmetic processor. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | assertion | hard | def solve_2(x):
return x*2
assert solve_2(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_2(x):
return x * 2 + 2
print(solve_2(10))
assert solve_2(10) == 22
assert solve_2(0) == 2
assert solve_2(5) == 12 | 22 | true | 172.15 | 88 | ||
Implement a transformation pipeline. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | zero_division | medium | def solve_3(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_3
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_3(x):
return x * 2 + 3
print(solve_3(10))
assert solve_3(10) == 23
assert solve_3(0) == 3
assert solve_3(5) == 13 | 23 | true | 169.22 | 147 | ||
Implement a transformation pipeline. Domain: math. Repair the failing implementation and verify correctness. | math | zero_division | medium | def solve_4(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_4
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_4(x):
return x * 2 + 4
print(solve_4(10))
assert solve_4(10) == 24
assert solve_4(0) == 4
assert solve_4(5) == 14 | 24 | true | 179.66 | 147 | ||
Implement a verified arithmetic processor. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | zero_division | medium | def solve_5(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_5
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_5(x):
return x * 2 + 5
print(solve_5(10))
assert solve_5(10) == 25
assert solve_5(0) == 5
assert solve_5(5) == 15 | 25 | true | 175.19 | 147 | ||
Implement a transformation pipeline. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | zero_division | medium | def solve_6(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_6
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_6(x):
return x * 2 + 6
print(solve_6(10))
assert solve_6(10) == 26
assert solve_6(0) == 6
assert solve_6(5) == 16 | 26 | true | 165.72 | 147 | ||
Fix the algorithm and validate outputs. Domain: science. Repair the failing implementation and verify correctness. | science | logic | hard | def solve_7(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_7(x):
return x * 2 + 7
print(solve_7(10))
assert solve_7(10) == 27
assert solve_7(0) == 7
assert solve_7(5) == 17 | 27 | true | 172.55 | 0 | ||
Fix the algorithm and validate outputs. Domain: math. Repair the failing implementation and verify correctness. | math | name_error | medium | def solve_8(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_8
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_8(x):
return x * 2 + 8
print(solve_8(10))
assert solve_8(10) == 28
assert solve_8(0) == 8
assert solve_8(5) == 18 | 28 | true | 170.63 | 163 | ||
Fix the algorithm and validate outputs. Domain: code. Repair the failing implementation and verify correctness. | code | key_error | hard | def solve_9(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_9
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_9(x):
return x * 2 + 9
print(solve_9(10))
assert solve_9(10) == 29
assert solve_9(0) == 9
assert solve_9(5) == 19 | 29 | true | 171.79 | 131 | ||
Create a function that doubles a value and applies an offset. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | syntax | medium | def solve_10(x): return x*/2 | File "<string>", line 1
def solve_10(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_10(x):
return x * 2 + 10
print(solve_10(10))
assert solve_10(10) == 30
assert solve_10(0) == 10
assert solve_10(5) == 20 | 30 | true | 171.71 | 116 | ||
Fix the failing implementation and validate edge cases. Domain: code. Repair the failing implementation and verify correctness. | code | name_error | medium | def solve_11(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_11
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_11(x):
return x * 2 + 11
print(solve_11(10))
assert solve_11(10) == 31
assert solve_11(0) == 11
assert solve_11(5) == 21 | 31 | true | 171.86 | 164 | ||
Implement a verified arithmetic processor. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | key_error | hard | def solve_12(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_12
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_12(x):
return x * 2 + 12
print(solve_12(10))
assert solve_12(10) == 32
assert solve_12(0) == 12
assert solve_12(5) == 22 | 32 | true | 192.04 | 132 | ||
Repair a broken computation function. Domain: automation. Repair the failing implementation and verify correctness. | automation | name_error | medium | def solve_13(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_13
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_13(x):
return x * 2 + 13
print(solve_13(10))
assert solve_13(10) == 33
assert solve_13(0) == 13
assert solve_13(5) == 23 | 33 | true | 171.33 | 164 | ||
Repair and verify a deterministic function. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | syntax | medium | def solve_14(x): return x*/2 | File "<string>", line 1
def solve_14(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_14(x):
return x * 2 + 14
print(solve_14(10))
assert solve_14(10) == 34
assert solve_14(0) == 14
assert solve_14(5) == 24 | 34 | true | 198.3 | 116 | ||
Repair a broken computation function. Domain: code. Repair the failing implementation and verify correctness. | code | assertion | hard | def solve_15(x):
return x*2
assert solve_15(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_15(x):
return x * 2 + 15
print(solve_15(10))
assert solve_15(10) == 35
assert solve_15(0) == 15
assert solve_15(5) == 25 | 35 | true | 174.68 | 88 | ||
Correct execution behavior and pass assertions. Domain: automation. Repair the failing implementation and verify correctness. | automation | syntax | medium | def solve_16(x): return x*/2 | File "<string>", line 1
def solve_16(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_16(x):
return x * 2 + 16
print(solve_16(10))
assert solve_16(10) == 36
assert solve_16(0) == 16
assert solve_16(5) == 26 | 36 | true | 178.87 | 116 | ||
Fix the algorithm and validate outputs. Domain: science. Repair the failing implementation and verify correctness. | science | index_error | hard | def solve_17(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_17
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_17(x):
return x * 2 + 17
print(solve_17(10))
assert solve_17(10) == 37
assert solve_17(0) == 17
assert solve_17(5) == 27 | 37 | true | 174.73 | 148 | ||
Implement a transformation pipeline. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | assertion | hard | def solve_18(x):
return x*2
assert solve_18(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_18(x):
return x * 2 + 18
print(solve_18(10))
assert solve_18(10) == 38
assert solve_18(0) == 18
assert solve_18(5) == 28 | 38 | true | 177.3 | 88 | ||
Implement a transformation pipeline. Domain: math. Repair the failing implementation and verify correctness. | math | key_error | hard | def solve_19(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_19
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_19(x):
return x * 2 + 19
print(solve_19(10))
assert solve_19(10) == 39
assert solve_19(0) == 19
assert solve_19(5) == 29 | 39 | true | 181.5 | 132 | ||
Implement a verified arithmetic processor. Domain: code. Repair the failing implementation and verify correctness. | code | index_error | hard | def solve_20(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_20
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_20(x):
return x * 2 + 20
print(solve_20(10))
assert solve_20(10) == 40
assert solve_20(0) == 20
assert solve_20(5) == 30 | 40 | true | 178.44 | 148 | ||
Correct execution behavior and pass assertions. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | type_error | medium | def solve_21(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_21
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_21(x):
return x * 2 + 21
print(solve_21(10))
assert solve_21(10) == 41
assert solve_21(0) == 21
assert solve_21(5) == 31 | 41 | true | 173.42 | 157 | ||
Implement a verified arithmetic processor. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | name_error | medium | def solve_22(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_22
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_22(x):
return x * 2 + 22
print(solve_22(10))
assert solve_22(10) == 42
assert solve_22(0) == 22
assert solve_22(5) == 32 | 42 | true | 169.76 | 164 | ||
Create a function that doubles a value and applies an offset. Domain: math. Repair the failing implementation and verify correctness. | math | name_error | medium | def solve_23(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_23
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_23(x):
return x * 2 + 23
print(solve_23(10))
assert solve_23(10) == 43
assert solve_23(0) == 23
assert solve_23(5) == 33 | 43 | true | 169.84 | 164 | ||
Fix the failing implementation and validate edge cases. Domain: math. Repair the failing implementation and verify correctness. | math | logic | hard | def solve_24(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_24(x):
return x * 2 + 24
print(solve_24(10))
assert solve_24(10) == 44
assert solve_24(0) == 24
assert solve_24(5) == 34 | 44 | true | 170.9 | 0 | ||
Repair and verify a deterministic function. Domain: science. Repair the failing implementation and verify correctness. | science | index_error | hard | def solve_25(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_25
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_25(x):
return x * 2 + 25
print(solve_25(10))
assert solve_25(10) == 45
assert solve_25(0) == 25
assert solve_25(5) == 35 | 45 | true | 169.12 | 148 | ||
Fix the algorithm and validate outputs. Domain: code. Repair the failing implementation and verify correctness. | code | logic | hard | def solve_26(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_26(x):
return x * 2 + 26
print(solve_26(10))
assert solve_26(10) == 46
assert solve_26(0) == 26
assert solve_26(5) == 36 | 46 | true | 168.53 | 0 | ||
Fix the algorithm and validate outputs. Domain: science. Repair the failing implementation and verify correctness. | science | logic | hard | def solve_27(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_27(x):
return x * 2 + 27
print(solve_27(10))
assert solve_27(10) == 47
assert solve_27(0) == 27
assert solve_27(5) == 37 | 47 | true | 170.4 | 0 | ||
Create a function that doubles a value and applies an offset. Domain: math. Repair the failing implementation and verify correctness. | math | name_error | medium | def solve_28(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_28
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_28(x):
return x * 2 + 28
print(solve_28(10))
assert solve_28(10) == 48
assert solve_28(0) == 28
assert solve_28(5) == 38 | 48 | true | 169.97 | 164 | ||
Repair a broken computation function. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | syntax | medium | def solve_29(x): return x*/2 | File "<string>", line 1
def solve_29(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_29(x):
return x * 2 + 29
print(solve_29(10))
assert solve_29(10) == 49
assert solve_29(0) == 29
assert solve_29(5) == 39 | 49 | true | 168.43 | 116 | ||
Fix the failing implementation and validate edge cases. Domain: code. Repair the failing implementation and verify correctness. | code | type_error | medium | def solve_30(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_30
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_30(x):
return x * 2 + 30
print(solve_30(10))
assert solve_30(10) == 50
assert solve_30(0) == 30
assert solve_30(5) == 40 | 50 | true | 169.93 | 157 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | assertion | hard | def solve_31(x):
return x*2
assert solve_31(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_31(x):
return x * 2 + 31
print(solve_31(10))
assert solve_31(10) == 51
assert solve_31(0) == 31
assert solve_31(5) == 41 | 51 | true | 169.34 | 88 | ||
Implement a transformation pipeline. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | name_error | medium | def solve_32(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_32
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_32(x):
return x * 2 + 32
print(solve_32(10))
assert solve_32(10) == 52
assert solve_32(0) == 32
assert solve_32(5) == 42 | 52 | true | 170.77 | 164 | ||
Repair and verify a deterministic function. Domain: code. Repair the failing implementation and verify correctness. | code | zero_division | medium | def solve_33(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_33
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_33(x):
return x * 2 + 33
print(solve_33(10))
assert solve_33(10) == 53
assert solve_33(0) == 33
assert solve_33(5) == 43 | 53 | true | 176.25 | 148 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | key_error | hard | def solve_34(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_34
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_34(x):
return x * 2 + 34
print(solve_34(10))
assert solve_34(10) == 54
assert solve_34(0) == 34
assert solve_34(5) == 44 | 54 | true | 174.22 | 132 | ||
Repair and verify a deterministic function. Domain: automation. Repair the failing implementation and verify correctness. | automation | key_error | hard | def solve_35(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_35
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_35(x):
return x * 2 + 35
print(solve_35(10))
assert solve_35(10) == 55
assert solve_35(0) == 35
assert solve_35(5) == 45 | 55 | true | 174.93 | 132 | ||
Correct execution behavior and pass assertions. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | zero_division | medium | def solve_36(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_36
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_36(x):
return x * 2 + 36
print(solve_36(10))
assert solve_36(10) == 56
assert solve_36(0) == 36
assert solve_36(5) == 46 | 56 | true | 170.52 | 148 | ||
Repair and verify a deterministic function. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | syntax | medium | def solve_37(x): return x*/2 | File "<string>", line 1
def solve_37(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_37(x):
return x * 2 + 37
print(solve_37(10))
assert solve_37(10) == 57
assert solve_37(0) == 37
assert solve_37(5) == 47 | 57 | true | 169.61 | 116 | ||
Implement a transformation pipeline. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | zero_division | medium | def solve_38(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_38
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_38(x):
return x * 2 + 38
print(solve_38(10))
assert solve_38(10) == 58
assert solve_38(0) == 38
assert solve_38(5) == 48 | 58 | true | 175.64 | 148 | ||
Repair and verify a deterministic function. Domain: code. Repair the failing implementation and verify correctness. | code | name_error | medium | def solve_39(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_39
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_39(x):
return x * 2 + 39
print(solve_39(10))
assert solve_39(10) == 59
assert solve_39(0) == 39
assert solve_39(5) == 49 | 59 | true | 174.36 | 164 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | assertion | hard | def solve_40(x):
return x*2
assert solve_40(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_40(x):
return x * 2 + 40
print(solve_40(10))
assert solve_40(10) == 60
assert solve_40(0) == 40
assert solve_40(5) == 50 | 60 | true | 168.33 | 88 | ||
Implement a transformation pipeline. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | assertion | hard | def solve_41(x):
return x*2
assert solve_41(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_41(x):
return x * 2 + 41
print(solve_41(10))
assert solve_41(10) == 61
assert solve_41(0) == 41
assert solve_41(5) == 51 | 61 | true | 173.37 | 88 | ||
Repair and verify a deterministic function. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | syntax | medium | def solve_42(x): return x*/2 | File "<string>", line 1
def solve_42(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_42(x):
return x * 2 + 42
print(solve_42(10))
assert solve_42(10) == 62
assert solve_42(0) == 42
assert solve_42(5) == 52 | 62 | true | 172.53 | 116 | ||
Repair a broken computation function. Domain: math. Repair the failing implementation and verify correctness. | math | key_error | hard | def solve_43(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_43
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_43(x):
return x * 2 + 43
print(solve_43(10))
assert solve_43(10) == 63
assert solve_43(0) == 43
assert solve_43(5) == 53 | 63 | true | 174.03 | 132 | ||
Implement a transformation pipeline. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | index_error | hard | def solve_44(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_44
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_44(x):
return x * 2 + 44
print(solve_44(10))
assert solve_44(10) == 64
assert solve_44(0) == 44
assert solve_44(5) == 54 | 64 | true | 174.69 | 148 | ||
Implement a verified arithmetic processor. Domain: automation. Repair the failing implementation and verify correctness. | automation | index_error | hard | def solve_45(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_45
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_45(x):
return x * 2 + 45
print(solve_45(10))
assert solve_45(10) == 65
assert solve_45(0) == 45
assert solve_45(5) == 55 | 65 | true | 168.33 | 148 | ||
Correct execution behavior and pass assertions. Domain: science. Repair the failing implementation and verify correctness. | science | key_error | hard | def solve_46(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_46
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_46(x):
return x * 2 + 46
print(solve_46(10))
assert solve_46(10) == 66
assert solve_46(0) == 46
assert solve_46(5) == 56 | 66 | true | 172.74 | 132 | ||
Correct execution behavior and pass assertions. Domain: code. Repair the failing implementation and verify correctness. | code | index_error | hard | def solve_47(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_47
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_47(x):
return x * 2 + 47
print(solve_47(10))
assert solve_47(10) == 67
assert solve_47(0) == 47
assert solve_47(5) == 57 | 67 | true | 175.16 | 148 | ||
Implement a verified arithmetic processor. Domain: code. Repair the failing implementation and verify correctness. | code | logic | hard | def solve_48(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_48(x):
return x * 2 + 48
print(solve_48(10))
assert solve_48(10) == 68
assert solve_48(0) == 48
assert solve_48(5) == 58 | 68 | true | 169.26 | 0 | ||
Fix the algorithm and validate outputs. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | zero_division | medium | def solve_49(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_49
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_49(x):
return x * 2 + 49
print(solve_49(10))
assert solve_49(10) == 69
assert solve_49(0) == 49
assert solve_49(5) == 59 | 69 | true | 173.33 | 148 | ||
Fix the algorithm and validate outputs. Domain: math. Repair the failing implementation and verify correctness. | math | key_error | hard | def solve_50(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_50
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_50(x):
return x * 2 + 50
print(solve_50(10))
assert solve_50(10) == 70
assert solve_50(0) == 50
assert solve_50(5) == 60 | 70 | true | 172.31 | 132 | ||
Repair a broken computation function. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | syntax | medium | def solve_51(x): return x*/2 | File "<string>", line 1
def solve_51(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_51(x):
return x * 2 + 51
print(solve_51(10))
assert solve_51(10) == 71
assert solve_51(0) == 51
assert solve_51(5) == 61 | 71 | true | 171.96 | 116 | ||
Implement a transformation pipeline. Domain: science. Repair the failing implementation and verify correctness. | science | zero_division | medium | def solve_52(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_52
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_52(x):
return x * 2 + 52
print(solve_52(10))
assert solve_52(10) == 72
assert solve_52(0) == 52
assert solve_52(5) == 62 | 72 | true | 169.9 | 148 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | zero_division | medium | def solve_53(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_53
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_53(x):
return x * 2 + 53
print(solve_53(10))
assert solve_53(10) == 73
assert solve_53(0) == 53
assert solve_53(5) == 63 | 73 | true | 165.85 | 148 | ||
Correct execution behavior and pass assertions. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | syntax | medium | def solve_54(x): return x*/2 | File "<string>", line 1
def solve_54(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_54(x):
return x * 2 + 54
print(solve_54(10))
assert solve_54(10) == 74
assert solve_54(0) == 54
assert solve_54(5) == 64 | 74 | true | 172.91 | 116 | ||
Correct execution behavior and pass assertions. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | assertion | hard | def solve_55(x):
return x*2
assert solve_55(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_55(x):
return x * 2 + 55
print(solve_55(10))
assert solve_55(10) == 75
assert solve_55(0) == 55
assert solve_55(5) == 65 | 75 | true | 168.88 | 88 | ||
Implement a transformation pipeline. Domain: science. Repair the failing implementation and verify correctness. | science | type_error | medium | def solve_56(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_56
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_56(x):
return x * 2 + 56
print(solve_56(10))
assert solve_56(10) == 76
assert solve_56(0) == 56
assert solve_56(5) == 66 | 76 | true | 167.59 | 157 | ||
Fix the failing implementation and validate edge cases. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | syntax | medium | def solve_57(x): return x*/2 | File "<string>", line 1
def solve_57(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_57(x):
return x * 2 + 57
print(solve_57(10))
assert solve_57(10) == 77
assert solve_57(0) == 57
assert solve_57(5) == 67 | 77 | true | 168.58 | 116 | ||
Repair a broken computation function. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | logic | hard | def solve_58(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_58(x):
return x * 2 + 58
print(solve_58(10))
assert solve_58(10) == 78
assert solve_58(0) == 58
assert solve_58(5) == 68 | 78 | true | 172.53 | 0 | ||
Correct execution behavior and pass assertions. Domain: math. Repair the failing implementation and verify correctness. | math | name_error | medium | def solve_59(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_59
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_59(x):
return x * 2 + 59
print(solve_59(10))
assert solve_59(10) == 79
assert solve_59(0) == 59
assert solve_59(5) == 69 | 79 | true | 174.4 | 164 | ||
Fix the algorithm and validate outputs. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | logic | hard | def solve_60(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_60(x):
return x * 2 + 60
print(solve_60(10))
assert solve_60(10) == 80
assert solve_60(0) == 60
assert solve_60(5) == 70 | 80 | true | 176.81 | 0 | ||
Fix the algorithm and validate outputs. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | zero_division | medium | def solve_61(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_61
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_61(x):
return x * 2 + 61
print(solve_61(10))
assert solve_61(10) == 81
assert solve_61(0) == 61
assert solve_61(5) == 71 | 81 | true | 169.39 | 148 | ||
Repair and verify a deterministic function. Domain: automation. Repair the failing implementation and verify correctness. | automation | logic | hard | def solve_62(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_62(x):
return x * 2 + 62
print(solve_62(10))
assert solve_62(10) == 82
assert solve_62(0) == 62
assert solve_62(5) == 72 | 82 | true | 170.8 | 0 | ||
Implement a verified arithmetic processor. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | assertion | hard | def solve_63(x):
return x*2
assert solve_63(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_63(x):
return x * 2 + 63
print(solve_63(10))
assert solve_63(10) == 83
assert solve_63(0) == 63
assert solve_63(5) == 73 | 83 | true | 168.46 | 88 | ||
Correct execution behavior and pass assertions. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | syntax | medium | def solve_64(x): return x*/2 | File "<string>", line 1
def solve_64(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_64(x):
return x * 2 + 64
print(solve_64(10))
assert solve_64(10) == 84
assert solve_64(0) == 64
assert solve_64(5) == 74 | 84 | true | 170.2 | 116 | ||
Correct execution behavior and pass assertions. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | key_error | hard | def solve_65(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_65
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_65(x):
return x * 2 + 65
print(solve_65(10))
assert solve_65(10) == 85
assert solve_65(0) == 65
assert solve_65(5) == 75 | 85 | true | 165.93 | 132 | ||
Correct execution behavior and pass assertions. Domain: science. Repair the failing implementation and verify correctness. | science | index_error | hard | def solve_66(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_66
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_66(x):
return x * 2 + 66
print(solve_66(10))
assert solve_66(10) == 86
assert solve_66(0) == 66
assert solve_66(5) == 76 | 86 | true | 171.1 | 148 | ||
Correct execution behavior and pass assertions. Domain: code. Repair the failing implementation and verify correctness. | code | key_error | hard | def solve_67(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_67
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_67(x):
return x * 2 + 67
print(solve_67(10))
assert solve_67(10) == 87
assert solve_67(0) == 67
assert solve_67(5) == 77 | 87 | true | 173.91 | 132 | ||
Repair and verify a deterministic function. Domain: science. Repair the failing implementation and verify correctness. | science | assertion | hard | def solve_68(x):
return x*2
assert solve_68(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_68(x):
return x * 2 + 68
print(solve_68(10))
assert solve_68(10) == 88
assert solve_68(0) == 68
assert solve_68(5) == 78 | 88 | true | 180.41 | 88 | ||
Create a function that doubles a value and applies an offset. Domain: code. Repair the failing implementation and verify correctness. | code | index_error | hard | def solve_69(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_69
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_69(x):
return x * 2 + 69
print(solve_69(10))
assert solve_69(10) == 89
assert solve_69(0) == 69
assert solve_69(5) == 79 | 89 | true | 170.36 | 148 | ||
Repair and verify a deterministic function. Domain: automation. Repair the failing implementation and verify correctness. | automation | syntax | medium | def solve_70(x): return x*/2 | File "<string>", line 1
def solve_70(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_70(x):
return x * 2 + 70
print(solve_70(10))
assert solve_70(10) == 90
assert solve_70(0) == 70
assert solve_70(5) == 80 | 90 | true | 188.32 | 116 | ||
Create a function that doubles a value and applies an offset. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | type_error | medium | def solve_71(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_71
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_71(x):
return x * 2 + 71
print(solve_71(10))
assert solve_71(10) == 91
assert solve_71(0) == 71
assert solve_71(5) == 81 | 91 | true | 172.98 | 157 | ||
Implement a verified arithmetic processor. Domain: code. Repair the failing implementation and verify correctness. | code | key_error | hard | def solve_72(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_72
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_72(x):
return x * 2 + 72
print(solve_72(10))
assert solve_72(10) == 92
assert solve_72(0) == 72
assert solve_72(5) == 82 | 92 | true | 185.87 | 132 | ||
Fix the algorithm and validate outputs. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | key_error | hard | def solve_73(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_73
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_73(x):
return x * 2 + 73
print(solve_73(10))
assert solve_73(10) == 93
assert solve_73(0) == 73
assert solve_73(5) == 83 | 93 | true | 168.11 | 132 | ||
Fix the failing implementation and validate edge cases. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | name_error | medium | def solve_74(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_74
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_74(x):
return x * 2 + 74
print(solve_74(10))
assert solve_74(10) == 94
assert solve_74(0) == 74
assert solve_74(5) == 84 | 94 | true | 171.58 | 164 | ||
Fix the algorithm and validate outputs. Domain: math. Repair the failing implementation and verify correctness. | math | syntax | medium | def solve_75(x): return x*/2 | File "<string>", line 1
def solve_75(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_75(x):
return x * 2 + 75
print(solve_75(10))
assert solve_75(10) == 95
assert solve_75(0) == 75
assert solve_75(5) == 85 | 95 | true | 184.28 | 116 | ||
Repair a broken computation function. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | index_error | hard | def solve_76(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_76
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_76(x):
return x * 2 + 76
print(solve_76(10))
assert solve_76(10) == 96
assert solve_76(0) == 76
assert solve_76(5) == 86 | 96 | true | 174.47 | 148 | ||
Correct execution behavior and pass assertions. Domain: science. Repair the failing implementation and verify correctness. | science | type_error | medium | def solve_77(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_77
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_77(x):
return x * 2 + 77
print(solve_77(10))
assert solve_77(10) == 97
assert solve_77(0) == 77
assert solve_77(5) == 87 | 97 | true | 168.82 | 157 | ||
Implement a transformation pipeline. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | key_error | hard | def solve_78(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_78
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_78(x):
return x * 2 + 78
print(solve_78(10))
assert solve_78(10) == 98
assert solve_78(0) == 78
assert solve_78(5) == 88 | 98 | true | 172.49 | 132 | ||
Implement a transformation pipeline. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | zero_division | medium | def solve_79(x):
return x / 0 | Traceback (most recent call last):
File "<string>", line 3, in <module>
File "<string>", line 2, in solve_79
ZeroDivisionError: division by zero | Analyze traceback. Identify zero_division failure. Repair implementation. Run assertions to verify correctness. | def solve_79(x):
return x * 2 + 79
print(solve_79(10))
assert solve_79(10) == 99
assert solve_79(0) == 79
assert solve_79(5) == 89 | 99 | true | 176.23 | 148 | ||
Correct execution behavior and pass assertions. Domain: code. Repair the failing implementation and verify correctness. | code | index_error | hard | def solve_80(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_80
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_80(x):
return x * 2 + 80
print(solve_80(10))
assert solve_80(10) == 100
assert solve_80(0) == 80
assert solve_80(5) == 90 | 100 | true | 186.92 | 148 | ||
Fix the algorithm and validate outputs. Domain: code. Repair the failing implementation and verify correctness. | code | assertion | hard | def solve_81(x):
return x*2
assert solve_81(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_81(x):
return x * 2 + 81
print(solve_81(10))
assert solve_81(10) == 101
assert solve_81(0) == 81
assert solve_81(5) == 91 | 101 | true | 178.61 | 88 | ||
Correct execution behavior and pass assertions. Domain: code. Repair the failing implementation and verify correctness. | code | type_error | medium | def solve_82(x): return len(x) + 2 | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_82
TypeError: object of type 'int' has no len() | Analyze traceback. Identify type_error failure. Repair implementation. Run assertions to verify correctness. | def solve_82(x):
return x * 2 + 82
print(solve_82(10))
assert solve_82(10) == 102
assert solve_82(0) == 82
assert solve_82(5) == 92 | 102 | true | 176.49 | 157 | ||
Implement a verified arithmetic processor. Domain: math. Repair the failing implementation and verify correctness. | math | name_error | medium | def solve_83(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_83
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_83(x):
return x * 2 + 83
print(solve_83(10))
assert solve_83(10) == 103
assert solve_83(0) == 83
assert solve_83(5) == 93 | 103 | true | 180.07 | 164 | ||
Implement a verified arithmetic processor. Domain: code. Repair the failing implementation and verify correctness. | code | assertion | hard | def solve_84(x):
return x*2
assert solve_84(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_84(x):
return x * 2 + 84
print(solve_84(10))
assert solve_84(10) == 104
assert solve_84(0) == 84
assert solve_84(5) == 94 | 104 | true | 180.92 | 88 | ||
Fix the algorithm and validate outputs. Domain: science. Repair the failing implementation and verify correctness. | science | syntax | medium | def solve_85(x): return x*/2 | File "<string>", line 1
def solve_85(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_85(x):
return x * 2 + 85
print(solve_85(10))
assert solve_85(10) == 105
assert solve_85(0) == 85
assert solve_85(5) == 95 | 105 | true | 179.67 | 116 | ||
Implement a verified arithmetic processor. Domain: science. Repair the failing implementation and verify correctness. | science | key_error | hard | def solve_86(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_86
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_86(x):
return x * 2 + 86
print(solve_86(10))
assert solve_86(10) == 106
assert solve_86(0) == 86
assert solve_86(5) == 96 | 106 | true | 173.54 | 132 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | key_error | hard | def solve_87(x):
d = {"a":1}
return d["missing"] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_87
KeyError: 'missing' | Analyze traceback. Identify key_error failure. Repair implementation. Run assertions to verify correctness. | def solve_87(x):
return x * 2 + 87
print(solve_87(10))
assert solve_87(10) == 107
assert solve_87(0) == 87
assert solve_87(5) == 97 | 107 | true | 169.32 | 132 | ||
Fix the failing implementation and validate edge cases. Domain: science. Repair the failing implementation and verify correctness. | science | assertion | hard | def solve_88(x):
return x*2
assert solve_88(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_88(x):
return x * 2 + 88
print(solve_88(10))
assert solve_88(10) == 108
assert solve_88(0) == 88
assert solve_88(5) == 98 | 108 | true | 168.6 | 88 | ||
Create a function that doubles a value and applies an offset. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | assertion | hard | def solve_89(x):
return x*2
assert solve_89(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_89(x):
return x * 2 + 89
print(solve_89(10))
assert solve_89(10) == 109
assert solve_89(0) == 89
assert solve_89(5) == 99 | 109 | true | 172.04 | 88 | ||
Implement a verified arithmetic processor. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | logic | hard | def solve_90(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_90(x):
return x * 2 + 90
print(solve_90(10))
assert solve_90(10) == 110
assert solve_90(0) == 90
assert solve_90(5) == 100 | 110 | true | 174.12 | 0 | ||
Implement a transformation pipeline. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | name_error | medium | def solve_91(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_91
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_91(x):
return x * 2 + 91
print(solve_91(10))
assert solve_91(10) == 111
assert solve_91(0) == 91
assert solve_91(5) == 101 | 111 | true | 176.85 | 164 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | logic | hard | def solve_92(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_92(x):
return x * 2 + 92
print(solve_92(10))
assert solve_92(10) == 112
assert solve_92(0) == 92
assert solve_92(5) == 102 | 112 | true | 167.16 | 0 | ||
Implement a verified arithmetic processor. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | syntax | medium | def solve_93(x): return x*/2 | File "<string>", line 1
def solve_93(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_93(x):
return x * 2 + 93
print(solve_93(10))
assert solve_93(10) == 113
assert solve_93(0) == 93
assert solve_93(5) == 103 | 113 | true | 168.71 | 116 | ||
Repair a broken computation function. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | name_error | medium | def solve_94(x): return x*2 + undefined_variable | Traceback (most recent call last):
File "<string>", line 2, in <module>
File "<string>", line 1, in solve_94
NameError: name 'undefined_variable' is not defined | Analyze traceback. Identify name_error failure. Repair implementation. Run assertions to verify correctness. | def solve_94(x):
return x * 2 + 94
print(solve_94(10))
assert solve_94(10) == 114
assert solve_94(0) == 94
assert solve_94(5) == 104 | 114 | true | 173.59 | 164 | ||
Fix the failing implementation and validate edge cases. Domain: math. Repair the failing implementation and verify correctness. | math | syntax | medium | def solve_95(x): return x*/2 | File "<string>", line 1
def solve_95(x): return x*/2
^
SyntaxError: invalid syntax | Analyze traceback. Identify syntax failure. Repair implementation. Run assertions to verify correctness. | def solve_95(x):
return x * 2 + 95
print(solve_95(10))
assert solve_95(10) == 115
assert solve_95(0) == 95
assert solve_95(5) == 105 | 115 | true | 176.25 | 116 | ||
Implement a verified arithmetic processor. Domain: data_processing. Repair the failing implementation and verify correctness. | data_processing | index_error | hard | def solve_96(x):
arr = [1,2]
return arr[10] | Traceback (most recent call last):
File "<string>", line 4, in <module>
File "<string>", line 3, in solve_96
IndexError: list index out of range | Analyze traceback. Identify index_error failure. Repair implementation. Run assertions to verify correctness. | def solve_96(x):
return x * 2 + 96
print(solve_96(10))
assert solve_96(10) == 116
assert solve_96(0) == 96
assert solve_96(5) == 106 | 116 | true | 176.18 | 148 | ||
Implement a verified arithmetic processor. Domain: reasoning. Repair the failing implementation and verify correctness. | reasoning | assertion | hard | def solve_97(x):
return x*2
assert solve_97(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_97(x):
return x * 2 + 97
print(solve_97(10))
assert solve_97(10) == 117
assert solve_97(0) == 97
assert solve_97(5) == 107 | 117 | true | 177.97 | 88 | ||
Repair and verify a deterministic function. Domain: algorithms. Repair the failing implementation and verify correctness. | algorithms | logic | hard | def solve_98(x): return x + 1 | 11 | Analyze traceback. Identify logic failure. Repair implementation. Run assertions to verify correctness. | def solve_98(x):
return x * 2 + 98
print(solve_98(10))
assert solve_98(10) == 118
assert solve_98(0) == 98
assert solve_98(5) == 108 | 118 | true | 169.52 | 0 | ||
Correct execution behavior and pass assertions. Domain: debugging. Repair the failing implementation and verify correctness. | debugging | assertion | hard | def solve_99(x):
return x*2
assert solve_99(10) == 999 | Traceback (most recent call last):
File "<string>", line 3, in <module>
AssertionError | Analyze traceback. Identify assertion failure. Repair implementation. Run assertions to verify correctness. | def solve_99(x):
return x * 2 + 99
print(solve_99(10))
assert solve_99(10) == 119
assert solve_99(0) == 99
assert solve_99(5) == 109 | 119 | true | 175.47 | 88 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.