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