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 min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_rename_variable_naive
|
def min_product_tuple(list1):
result_min = min([abs(VAR_0 * y) for VAR_0, y in list1])
return result_min
| 1 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_rename_variable_rn
|
def min_product_tuple(list1):
result_min = min([abs(N * y) for N, y in list1])
return result_min
| 1 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_mul_div_variable
|
def min_product_tuple(list1):
result_min = min([abs(x / y) for x, y in list1] )
return result_min
| 0 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 406 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dead_code_insert
|
def min_val(listval):
for _i_4 in range(0):
return min_val
min_val = min(i for i in listval if isinstance(i, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_for_while_loop
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_operand_swap
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_rename_variable_cb
|
def min_val(listval):
min_val = min(f for f in listval if isinstance(f, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_rename_variable_naive
|
def min_val(listval):
min_val = min(VAR_0 for VAR_0 in listval if isinstance(VAR_0, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_rename_variable_rn
|
def min_val(listval):
min_val = min(R for R in listval if isinstance(R, int))
return min_val
| 1 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 407 |
mbpp
|
def min_val(listval):
min_val = min(i for i in listval if isinstance(i, int))
return min_val
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 407 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dead_code_insert
|
def extract_nth_element(list1, n):
if False:
result = [x[n] for x in list1]
result = [x[n] for x in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_for_while_loop
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_operand_swap
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_rename_variable_cb
|
def extract_nth_element(list1, n):
result = [e[n] for e in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_rename_variable_naive
|
def extract_nth_element(list1, n):
result = [VAR_0[n] for VAR_0 in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_rename_variable_rn
|
def extract_nth_element(list1, n):
result = [S[n] for S in list1]
return result
| 1 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 410 |
mbpp
|
def extract_nth_element(list1, n):
result = [x[n] for x in list1]
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 410 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dead_code_insert
|
def breakSum(n):
MAX = 1000000
dp = [0] * (n + 1)
for _i_4 in range(0):
dp[0] = 0
dp[0] = 0
dp[1] = 1
for i in range(2, n + 1):
dp[i] = max(dp[int(i / 2)] + dp[int(i / 3)] + dp[int(i / 4)], i)
return dp[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_for_while_loop
|
def breakSum(n):
MAX = 1000000
dp = [0] * (n + 1)
dp[0] = 0
dp[1] = 1
i = 2
while i < n + 1:
dp[i] = max(dp[int(i / 2)] + dp[int(i / 3)] + dp[int(i / 4)], i)
i += 1
return dp[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_operand_swap
|
def breakSum(n):
MAX = 1000000
dp = [0] * (n + 1)
dp[0] = 0
dp[1] = 1
for i in range(2, n + 1):
dp[i] = max(dp[int(i / 2)] + dp[int(i / 3)] + dp[int(i / 4)], i)
return dp[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_rename_variable_cb
|
def breakSum(n):
MAX = 1000000
max = [0] * (n + 1)
max[0] = 0
max[1] = 1
for i in range(2, n + 1):
max[i] = max(max[int(i / 2)] + max[int(i / 3)] + max[int(i / 4)], i)
return max[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_rename_variable_naive
|
def breakSum(n):
MAX = 1000000
VAR_0 = [0] * (n + 1)
VAR_0[0] = 0
VAR_0[1] = 1
for i in range(2, n + 1):
VAR_0[i] = max(VAR_0[int(i / 2)] + VAR_0[int(i / 3)] + VAR_0[int(i / 4)], i)
return VAR_0[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_rename_variable_rn
|
def breakSum(n):
MAX = 1000000
B8 = [0] * (n + 1)
B8[0] = 0
B8[1] = 1
for i in range(2, n + 1):
B8[i] = max(B8[int(i / 2)] + B8[int(i / 3)] + B8[int(i / 4)], i)
return B8[n]
| 1 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_add_sub_variable
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n-1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_mul_div_variable
|
def breakSum(n):
MAX = 1000000
dp = [0]/(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_div_mul_variable
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i*2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 413 |
mbpp
|
def breakSum(n):
MAX = 1000000
dp = [0]*(n+1)
dp[0] = 0
dp[1] = 1
for i in range(2, n+1):
dp[i] = max(dp[int(i/2)] + dp[int(i/3)] + dp[int(i/4)], i);
return dp[n]
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 413 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dead_code_insert
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
_i_4 = 0
while _i_4 > _i_4:
out = {}
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_for_while_loop
|
def group_tuples(Input):
out = {}
_elem_i = 0
while _elem_i < len(Input):
elem = Input[_elem_i]
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
_elem_i += 1
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_operand_swap
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_rename_variable_cb
|
def group_tuples(Input):
out = {}
for line in Input:
try:
out[line[0]].extend(line[1:])
except KeyError:
out[line[0]] = list(line)
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_rename_variable_naive
|
def group_tuples(Input):
out = {}
for VAR_0 in Input:
try:
out[VAR_0[0]].extend(VAR_0[1:])
except KeyError:
out[VAR_0[0]] = list(VAR_0)
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_rename_variable_rn
|
def group_tuples(Input):
out = {}
for m0e8 in Input:
try:
out[m0e8[0]].extend(m0e8[1:])
except KeyError:
out[m0e8[0]] = list(m0e8)
return [tuple(values) for values in out.values()]
| 1 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 414 |
mbpp
|
def group_tuples(Input):
out = {}
for elem in Input:
try:
out[elem[0]].extend(elem[1:])
except KeyError:
out[elem[0]] = list(elem)
return [tuple(values) for values in out.values()]
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 414 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dead_code_insert
|
def Find_Max(lst):
for _i_1 in range(0):
return maxList
maxList = max((x) for x in lst)
return maxList
| 1 | 415 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 415 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 415 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 415 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 415 |
mbpp
|
def Find_Max(lst):
maxList = max((x) for x in lst)
return maxList
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 415 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dead_code_insert
|
def concatenate_tuple(test_tup):
while False:
return str(res)
delim = "-"
res = "".join([str(ele) + delim for ele in test_tup])
res = res[: len(res) - len(delim)]
return str(res)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_for_while_loop
|
def concatenate_tuple(test_tup):
delim = "-"
res = "".join([str(ele) + delim for ele in test_tup])
res = res[: len(res) - len(delim)]
return str(res)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_operand_swap
|
def concatenate_tuple(test_tup):
delim = "-"
res = "".join([str(ele) + delim for ele in test_tup])
res = res[: len(res) - len(delim)]
return str(res)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_rename_variable_cb
|
def concatenate_tuple(test_tup):
delim = "-"
line = "".join([str(ele) + delim for ele in test_tup])
line = line[: len(line) - len(delim)]
return str(line)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_rename_variable_naive
|
def concatenate_tuple(test_tup):
delim = "-"
VAR_0 = "".join([str(ele) + delim for ele in test_tup])
VAR_0 = VAR_0[: len(VAR_0) - len(delim)]
return str(VAR_0)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_rename_variable_rn
|
def concatenate_tuple(test_tup):
delim = "-"
O5O = "".join([str(ele) + delim for ele in test_tup])
O5O = O5O[: len(O5O) - len(delim)]
return str(O5O)
| 1 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_add_sub_variable
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) - delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_sub_add_variable
|
def concatenate_tuple(test_tup):
delim = "+"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 418 |
mbpp
|
def concatenate_tuple(test_tup):
delim = "-"
res = ''.join([str(ele) + delim for ele in test_tup])
res = res[ : len(res) - len(delim)]
return (str(res))
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 418 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dead_code_insert
|
def find_Average_Of_Cube(n):
for _i_9 in range(0):
sum = 0
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_for_while_loop
|
def find_Average_Of_Cube(n):
sum = 0
i = 1
while i < n + 1:
sum += i * i * i
i += 1
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_operand_swap
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_rename_variable_cb
|
def find_Average_Of_Cube(n):
sum = 0
for n2 in range(1, n + 1):
sum += n2 * n2 * n2
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_rename_variable_naive
|
def find_Average_Of_Cube(n):
sum = 0
for VAR_0 in range(1, n + 1):
sum += VAR_0 * VAR_0 * VAR_0
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_rename_variable_rn
|
def find_Average_Of_Cube(n):
sum = 0
for d in range(1, n + 1):
sum += d * d * d
return round(sum / n, 6)
| 1 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_add_sub_variable
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n - 1):
sum += i * i * i
return round(sum / n, 6)
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_mul_div_variable
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i / i * i
return round(sum / n, 6)
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_div_mul_variable
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum * n, 6)
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 419 |
mbpp
|
def find_Average_Of_Cube(n):
sum = 0
for i in range(1, n + 1):
sum += i * i * i
return round(sum / n, 6)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 419 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dead_code_insert
|
def extract_rear(test_tuple):
if False:
return res
res = list(sub[len(sub) - 1] for sub in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_for_while_loop
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_operand_swap
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_rename_variable_cb
|
def extract_rear(test_tuple):
res = list(test[len(test) - 1] for test in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_rename_variable_naive
|
def extract_rear(test_tuple):
res = list(VAR_0[len(VAR_0) - 1] for VAR_0 in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_rename_variable_rn
|
def extract_rear(test_tuple):
res = list(J19[len(J19) - 1] for J19 in test_tuple)
return res
| 1 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_sub_add_variable
|
def extract_rear(test_tuple):
res = list(sub[len(sub) + 1] for sub in test_tuple)
return (res)
| 0 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 421 |
mbpp
|
def extract_rear(test_tuple):
res = list(sub[len(sub) - 1] for sub in test_tuple)
return (res)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 421 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.