original_code stringclasses 565
values | transformation stringclasses 24
values | transformed_code stringlengths 35 955 | label int64 0 1 | groups int64 1 971 | dataset stringclasses 1
value |
|---|---|---|---|---|---|
def closest_integer(value):
from math import floor, ceil
if value.count('.') == 1:
# remove trailing zeros
while (value[-1] == '0'):
value = value[:-1]
num = float(value)
if value[-2:] == '.5':
if num > 0:
res = ceil(num)
else:
res = fl... | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 98 | mbpp |
def closest_integer(value):
from math import floor, ceil
if value.count('.') == 1:
# remove trailing zeros
while (value[-1] == '0'):
value = value[:-1]
num = float(value)
if value[-2:] == '.5':
if num > 0:
res = ceil(num)
else:
res = fl... | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 98 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_add_sub_variable | def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_sub_add_variable | def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
+ the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_mul_div_variable | def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_greater_lesser_variable | def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_is_isnot_variable | def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is not odd.
- the next even number if n is even.
Return the number of stones in each ... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 99 | mbpp |
def make_a_pile(n):
"""
Given a positive integer n, you have to make a pile of n levels of stones.
The first level has n stones.
The number of stones in the next level is:
- the next odd number if n is odd.
- the next even number if n is even.
Return the number of stones in each leve... | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 99 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dead_code_insert | def rounded_avg(n, m):
if m < n:
return -1
summation = 0
while False:
return bin(round(summation / (m - n + 1)))
for i in range(n, m + 1):
summation += i
return bin(round(summation / (m - n + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_for_while_loop | def rounded_avg(n, m):
if m < n:
return -1
summation = 0
i = n
while i < m + 1:
summation += i
i += 1
return bin(round(summation / (m - n + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_operand_swap | def rounded_avg(n, m):
if n > m:
return -1
summation = 0
for i in range(n, m + 1):
summation += i
return bin(round(summation / (m - n + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_rename_variable_cb | def rounded_avg(n, n2):
if n2 < n:
return -1
summation = 0
for i in range(n, n2 + 1):
summation += i
return bin(round(summation / (n2 - n + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_rename_variable_naive | def rounded_avg(n, VAR_0):
if VAR_0 < n:
return -1
summation = 0
for i in range(n, VAR_0 + 1):
summation += i
return bin(round(summation / (VAR_0 - n + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_rename_variable_rn | def rounded_avg(m2, m):
if m < m2:
return -1
summation = 0
for i in range(m2, m + 1):
summation += i
return bin(round(summation / (m - m2 + 1))) | 1 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_add_sub_variable | def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m-1):
summation += i
return bin(round(summation/(m - n + 1))) | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_sub_add_variable | def rounded_avg(n, m):
if m < n:
return +1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_div_mul_variable | def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation*(m - n + 1))) | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_lesser_greater_variable | def rounded_avg(n, m):
if m > n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 102 | mbpp |
def rounded_avg(n, m):
if m < n:
return -1
summation = 0
for i in range(n, m+1):
summation += i
return bin(round(summation/(m - n + 1))) | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 102 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dead_code_insert | def unique_digits(x):
odd_digit_elements = []
for i in x:
_i_3 = 0
while _i_3 < _i_3:
return sorted(odd_digit_elements)
if all(int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_for_while_loop | def unique_digits(x):
odd_digit_elements = []
_i_i = 0
while _i_i < len(x):
i = x[_i_i]
if all(int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
_i_i += 1
return sorted(odd_digit_elements) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_operand_swap | def unique_digits(x):
odd_digit_elements = []
for i in x:
if all(1 == int(c) % 2 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_rename_variable_cb | def unique_digits(x):
odd_digit_elements = []
for g in x:
if all(int(c) % 2 == 1 for c in str(g)):
odd_digit_elements.append(g)
return sorted(odd_digit_elements) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_rename_variable_naive | def unique_digits(x):
VAR_0 = []
for i in x:
if all(int(c) % 2 == 1 for c in str(i)):
VAR_0.append(i)
return sorted(VAR_0) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_rename_variable_rn | def unique_digits(x):
odd_digit_elements = []
for b in x:
if all(int(c) % 2 == 1 for c in str(b)):
odd_digit_elements.append(b)
return sorted(odd_digit_elements) | 1 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_equalto_exclamation_variable | def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 != 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | 0 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 103 | mbpp |
def unique_digits(x):
odd_digit_elements = []
for i in x:
if all (int(c) % 2 == 1 for c in str(i)):
odd_digit_elements.append(i)
return sorted(odd_digit_elements) | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 103 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dead_code_insert | def even_odd_palindrome(n):
def is_palindrome(n):
_i_7 = 0
if _i_7 < _i_7:
odd_palindrome_count = 0
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n + 1):
if i % 2 == 1 and is_palindrome(i):
o... | 1 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_for_while_loop | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
i = 1
while i < n + 1:
if i % 2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i % 2 == 0 and is_palindrome(i):
... | 1 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_rename_variable_cb | def even_odd_palindrome(eve):
def is_palindrome(eve):
return str(eve) == str(eve)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, eve + 1):
if i % 2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i % 2 == 0 and is_palindrome(i... | 1 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_rename_variable_naive | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for VAR_0 in range(1, n + 1):
if VAR_0 % 2 == 1 and is_palindrome(VAR_0):
odd_palindrome_count += 1
elif VAR_0 % 2 == 0 and is_palind... | 1 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_rename_variable_rn | def even_odd_palindrome(Z):
def is_palindrome(Z):
return str(Z) == str(Z)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, Z + 1):
if i % 2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i % 2 == 0 and is_palindrome(i):
... | 1 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_add_sub_variable | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n-1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_sub_add_variable | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::+1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_equalto_exclamation_variable | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) != str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_and_or_variable | def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 or is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
ev... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 105 | mbpp |
def even_odd_palindrome(n):
def is_palindrome(n):
return str(n) == str(n)[::-1]
even_palindrome_count = 0
odd_palindrome_count = 0
for i in range(1, n+1):
if i%2 == 1 and is_palindrome(i):
odd_palindrome_count += 1
elif i%2 == 0 and is_palindrome(i):
e... | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 105 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dead_code_insert | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0:
for _i_4 in range(0):
n[0] = n[0] * neg
n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digi... | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_for_while_loop | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0:
n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_operand_swap | def count_nums(arr):
def digits_sum(n):
neg = 1
if 0 > n:
n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_rename_variable_cb | def count_nums(arr):
def digits_sum(arr2):
neg = 1
if arr2 < 0:
arr2, neg = -1 * arr2, -1
arr2 = [int(i) for i in str(arr2)]
arr2[0] = arr2[0] * neg
return sum(arr2)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_rename_variable_naive | def count_nums(arr):
def digits_sum(VAR_0):
neg = 1
if VAR_0 < 0:
VAR_0, neg = -1 * VAR_0, -1
VAR_0 = [int(i) for i in str(VAR_0)]
VAR_0[0] = VAR_0[0] * neg
return sum(VAR_0)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_rename_variable_rn | def count_nums(arr):
def digits_sum(q):
neg = 1
if q < 0:
q, neg = -1 * q, -1
q = [int(i) for i in str(q)]
q[0] = q[0] * neg
return sum(q)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 1 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_sub_add_variable | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = +1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_mul_div_variable | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 / n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_lesser_greater_variable | def count_nums(arr):
def digits_sum(n):
neg = 1
if n > 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_greater_lesser_variable | def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x < 0, [digits_sum(i) for i in arr]))) | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 106 | mbpp |
def count_nums(arr):
def digits_sum(n):
neg = 1
if n < 0: n, neg = -1 * n, -1
n = [int(i) for i in str(n)]
n[0] = n[0] * neg
return sum(n)
return len(list(filter(lambda x: x > 0, [digits_sum(i) for i in arr]))) | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 106 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dead_code_insert | def odd_count(lst):
for _i_2 in range(0):
n = sum(int(d) % 2 == 1 for d in arr)
res = []
for arr in lst:
n = sum(int(d) % 2 == 1 for d in arr)
res.append(
"the number of odd elements "
+ str(n)
+ "n the str"
+ str(n)
... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_for_while_loop | def odd_count(lst):
res = []
_arr_i = 0
while _arr_i < len(lst):
arr = lst[_arr_i]
n = sum(int(d) % 2 == 1 for d in arr)
res.append(
"the number of odd elements "
+ str(n)
+ "n the str"
+ str(n)
+ "ng "
+... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_operand_swap | def odd_count(lst):
res = []
for arr in lst:
n = sum(1 == int(d) % 2 for d in arr)
res.append(
"the number of odd elements "
+ str(n)
+ "n the str"
+ str(n)
+ "ng "
+ str(n)
+ " of the "
+ str... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_rename_variable_cb | def odd_count(lst):
res = []
for arr in lst:
ts = sum(int(d) % 2 == 1 for d in arr)
res.append(
"the number of odd elements "
+ str(ts)
+ "n the str"
+ str(ts)
+ "ng "
+ str(ts)
+ " of the "
+... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_rename_variable_naive | def odd_count(lst):
res = []
for arr in lst:
VAR_0 = sum(int(d) % 2 == 1 for d in arr)
res.append(
"the number of odd elements "
+ str(VAR_0)
+ "n the str"
+ str(VAR_0)
+ "ng "
+ str(VAR_0)
+ " of the "
... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_rename_variable_rn | def odd_count(lst):
res = []
for arr in lst:
P = sum(int(d) % 2 == 1 for d in arr)
res.append(
"the number of odd elements "
+ str(P)
+ "n the str"
+ str(P)
+ "ng "
+ str(P)
+ " of the "
+ str... | 1 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_add_sub_variable | def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " - str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_equalto_exclamation_variable | def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2!=1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 111 | mbpp |
def odd_count(lst):
res = []
for arr in lst:
n = sum(int(d)%2==1 for d in arr)
res.append("the number of odd elements " + str(n) + "n the str"+ str(n) +"ng "+ str(n) +" of the "+ str(n) +"nput.")
return res | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 111 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dead_code_insert | def minSubArraySum(nums):
max_sum = 0
_i_5 = 0
if _i_5 < _i_5:
max_sum = 0
s = 0
for num in nums:
s += -num
if s < 0:
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return... | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_for_while_loop | def minSubArraySum(nums):
max_sum = 0
s = 0
_num_i = 0
while _num_i < len(nums):
num = nums[_num_i]
s += -num
if s < 0:
s = 0
max_sum = max(s, max_sum)
_num_i += 1
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -... | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_operand_swap | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if s < 0:
s = 0
max_sum = max(s, max_sum)
if 0 == max_sum:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_rename_variable_cb | def minSubArraySum(nums):
s2 = 0
s = 0
for num in nums:
s += -num
if s < 0:
s = 0
s2 = max(s, s2)
if s2 == 0:
s2 = max(-i for i in nums)
min_sum = -s2
return min_sum | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_rename_variable_naive | def minSubArraySum(nums):
VAR_0 = 0
s = 0
for num in nums:
s += -num
if s < 0:
s = 0
VAR_0 = max(s, VAR_0)
if VAR_0 == 0:
VAR_0 = max(-i for i in nums)
min_sum = -VAR_0
return min_sum | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_rename_variable_rn | def minSubArraySum(nums):
OIrC38d = 0
s = 0
for num in nums:
s += -num
if s < 0:
s = 0
OIrC38d = max(s, OIrC38d)
if OIrC38d == 0:
OIrC38d = max(-i for i in nums)
min_sum = -OIrC38d
return min_sum | 1 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_add_sub_variable | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s -= -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_sub_add_variable | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += +num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_lesser_greater_variable | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s > 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_equalto_exclamation_variable | def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum != 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dissimilar_code_injection_0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
re... | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dissimilar_code_injection_1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
... | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dissimilar_code_injection_2 | 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.5
... | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dissimilar_code_injection_3 | from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False | 0 | 112 | mbpp |
def minSubArraySum(nums):
max_sum = 0
s = 0
for num in nums:
s += -num
if (s < 0):
s = 0
max_sum = max(s, max_sum)
if max_sum == 0:
max_sum = max(-i for i in nums)
min_sum = -max_sum
return min_sum | transformation_dissimilar_code_injection_4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers) | 0 | 112 | mbpp |
def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result | transformation_dead_code_insert | def select_words(s, n):
_i_4 = 0
while _i_4 < _i_4:
return result
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a", "e", "i", "o", "u"]:
n_consonants += 1
if n_cons... | 1 | 115 | mbpp |
def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result | transformation_for_while_loop | def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
i = 0
while i < len(word):
if word[i].lower() not in ["a", "e", "i", "o", "u"]:
n_consonants += 1
i += 1
if n_consonants == n:
result.ap... | 1 | 115 | mbpp |
def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result | transformation_operand_swap | def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a", "e", "i", "o", "u"]:
n_consonants += 1
if n == n_consonants:
result.append(word)
return re... | 1 | 115 | mbpp |
def select_words(s, n):
result = []
for word in s.split():
n_consonants = 0
for i in range(0, len(word)):
if word[i].lower() not in ["a","e","i","o","u"]:
n_consonants += 1
if n_consonants == n:
result.append(word)
return result | transformation_rename_variable_cb | def select_words(s, n):
result = []
for s2 in s.split():
n_consonants = 0
for i in range(0, len(s2)):
if s2[i].lower() not in ["a", "e", "i", "o", "u"]:
n_consonants += 1
if n_consonants == n:
result.append(s2)
return result | 1 | 115 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.