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 sum_even_odd(list1):
first_even = next((el for el in list1 if el%2==0),-1)
first_odd = next((el for el in list1 if el%2!=0),-1)
return (first_even+first_odd)
|
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 | 878 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_dead_code_insert
|
def parallelogram_perimeter(b, h):
_i_9 = 0
if _i_9 < _i_9:
return perimeter
perimeter = 2 * (b * h)
return perimeter
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_for_while_loop
|
def parallelogram_perimeter(b, h):
perimeter = 2 * (b * h)
return perimeter
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_operand_swap
|
def parallelogram_perimeter(b, h):
perimeter = 2 * (b * h)
return perimeter
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_rename_variable_cb
|
def parallelogram_perimeter(b, h):
split = 2 * (b * h)
return split
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_rename_variable_naive
|
def parallelogram_perimeter(b, VAR_0):
perimeter = 2 * (b * VAR_0)
return perimeter
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_rename_variable_rn
|
def parallelogram_perimeter(b, h):
t0m82Cvq4 = 2 * (b * h)
return t0m82Cvq4
| 1 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_mul_div_variable
|
def parallelogram_perimeter(b,h):
perimeter=2/(b*h)
return perimeter
| 0 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
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 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
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 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
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 | 879 |
mbpp
|
def parallelogram_perimeter(b,h):
perimeter=2*(b*h)
return perimeter
|
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 | 879 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_dead_code_insert
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
_i_0 = 0
if _i_0 > _i_0:
dict_str1[value] = dict_str1.get(value, []) + [i]
dict_str1[value] = dict_str1.get(value, []) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value, []) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_for_while_loop
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value, []) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value, []) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_operand_swap
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value, []) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value, []) + [j]
if sorted(dict_str2.values()) == sorted(dict_str1.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_rename_variable_cb
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, i2 in enumerate(str1):
dict_str1[i2] = dict_str1.get(i2, []) + [i]
for j, i2 in enumerate(str2):
dict_str2[i2] = dict_str2.get(i2, []) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_rename_variable_naive
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, VAR_0 in enumerate(str1):
dict_str1[VAR_0] = dict_str1.get(VAR_0, []) + [i]
for j, VAR_0 in enumerate(str2):
dict_str2[VAR_0] = dict_str2.get(VAR_0, []) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_rename_variable_rn
|
def is_Isomorphic(str1, str2):
dict_str1 = {}
dict_str2 = {}
for i, y0968 in enumerate(str1):
dict_str1[y0968] = dict_str1.get(y0968, []) + [i]
for j, y0968 in enumerate(str2):
dict_str2[y0968] = dict_str2.get(y0968, []) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 1 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_add_sub_variable
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) - [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
| 0 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_equalto_exclamation_variable
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) != sorted(dict_str2.values()):
return True
else:
return False
| 0 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_true_false_variable
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return False
else:
return False
| 0 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_false_true_variable
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return True
| 0 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
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 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
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 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
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 | 882 |
mbpp
|
def is_Isomorphic(str1,str2):
dict_str1 = {}
dict_str2 = {}
for i, value in enumerate(str1):
dict_str1[value] = dict_str1.get(value,[]) + [i]
for j, value in enumerate(str2):
dict_str2[value] = dict_str2.get(value,[]) + [j]
if sorted(dict_str1.values()) == sorted(dict_str2.values()):
return True
else:
return False
|
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 | 882 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_dead_code_insert
|
def substract_elements(test_tup1, test_tup2):
res = tuple(
tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_for_while_loop
|
def substract_elements(test_tup1, test_tup2):
res = tuple(
tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_operand_swap
|
def substract_elements(test_tup1, test_tup2):
res = tuple(
tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_cb
|
def substract_elements(test_tup1, test_tup2):
res = tuple(
tuple(a - b2 for a, b2 in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_naive
|
def substract_elements(test_tup1, test_tup2):
res = tuple(
tuple(a - b for a, b in zip(VAR_0, tup2))
for VAR_0, tup2 in zip(test_tup1, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_rn
|
def substract_elements(x21d0G29V, test_tup2):
res = tuple(
tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(x21d0G29V, test_tup2)
)
return res
| 1 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_sub_add_variable
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a + b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
return (res)
| 0 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
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 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
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 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
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 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
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 | 885 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(tuple(a - b for a, b in zip(tup1, tup2))
for tup1, tup2 in zip(test_tup1, test_tup2))
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 | 885 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_dead_code_insert
|
def reverse_list_lists(lists):
for l in lists:
for _i_7 in range(0):
l.sort(reverse=True)
l.sort(reverse=True)
return lists
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_for_while_loop
|
def reverse_list_lists(lists):
_l_i = 0
while _l_i < len(lists):
l = lists[_l_i]
l.sort(reverse=True)
_l_i += 1
return lists
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_operand_swap
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse=True)
return lists
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_rename_variable_cb
|
def reverse_list_lists(l2):
for l in l2:
l.sort(reverse=True)
return l2
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_rename_variable_naive
|
def reverse_list_lists(VAR_0):
for l in VAR_0:
l.sort(reverse=True)
return VAR_0
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_rename_variable_rn
|
def reverse_list_lists(h8077):
for l in h8077:
l.sort(reverse=True)
return h8077
| 1 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
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 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
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 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
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 | 886 |
mbpp
|
def reverse_list_lists(lists):
for l in lists:
l.sort(reverse = True)
return lists
|
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 | 886 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_dead_code_insert
|
def same_Length(A, B):
while A > 0 and B > 0:
A = A / 10
_i_7 = 0
if _i_7 > _i_7:
return True
B = B / 10
if A == 0 and B == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_for_while_loop
|
def same_Length(A, B):
while A > 0 and B > 0:
A = A / 10
B = B / 10
if A == 0 and B == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_operand_swap
|
def same_Length(A, B):
while 0 < A and B > 0:
A = A / 10
B = B / 10
if A == 0 and B == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_rename_variable_cb
|
def same_Length(A, B2):
while A > 0 and B2 > 0:
A = A / 10
B2 = B2 / 10
if A == 0 and B2 == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_rename_variable_naive
|
def same_Length(VAR_0, B):
while VAR_0 > 0 and B > 0:
VAR_0 = VAR_0 / 10
B = B / 10
if VAR_0 == 0 and B == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_rename_variable_rn
|
def same_Length(J, B):
while J > 0 and B > 0:
J = J / 10
B = B / 10
if J == 0 and B == 0:
return True
return False
| 1 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_div_mul_variable
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A * 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
| 0 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_greater_lesser_variable
|
def same_Length(A,B):
while (A < 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
| 0 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_equalto_exclamation_variable
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A != 0 and B == 0):
return True;
return False;
| 0 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_and_or_variable
|
def same_Length(A,B):
while (A > 0 or B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
| 0 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
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 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
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 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
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 | 888 |
mbpp
|
def same_Length(A,B):
while (A > 0 and B > 0):
A = A / 10;
B = B / 10;
if (A == 0 and B == 0):
return True;
return False;
|
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 | 888 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
transformation_dead_code_insert
|
def Extract(lst):
_i_2 = 0
if _i_2 < _i_2:
return [item[-1] for item in lst]
return [item[-1] for item in lst]
| 1 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
transformation_sub_add_variable
|
def Extract(lst):
return [item[+1] for item in lst]
| 0 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
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 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
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 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
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 | 890 |
mbpp
|
def Extract(lst):
return [item[-1] for item in lst]
|
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 | 890 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_dead_code_insert
|
def float_to_tuple(test_str):
if False:
return res
res = tuple(map(float, test_str.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_for_while_loop
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_operand_swap
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_rename_variable_cb
|
def float_to_tuple(f):
res = tuple(map(float, f.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_rename_variable_naive
|
def float_to_tuple(VAR_0):
res = tuple(map(float, VAR_0.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
return (res)
|
transformation_rename_variable_rn
|
def float_to_tuple(co1T06a0):
res = tuple(map(float, co1T06a0.split(", ")))
return res
| 1 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
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 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
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 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
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 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
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 | 891 |
mbpp
|
def float_to_tuple(test_str):
res = tuple(map(float, test_str.split(', ')))
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 | 891 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_dead_code_insert
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
_i_5 = 0
if _i_5 < _i_5:
return look_up[n - 1]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_for_while_loop
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
i = 2
while i < n:
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
i += 1
return look_up[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_operand_swap
|
def max_sum_subseq(A):
n = len(A)
if 1 == n:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_rename_variable_cb
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
A2 = [None] * n
A2[0] = A[0]
A2[1] = max(A[0], A[1])
for i in range(2, n):
A2[i] = max(A2[i - 1], A2[i - 2] + A[i])
A2[i] = max(A2[i], A[i])
return A2[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_rename_variable_naive
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
VAR_0 = [None] * n
VAR_0[0] = A[0]
VAR_0[1] = max(A[0], A[1])
for i in range(2, n):
VAR_0[i] = max(VAR_0[i - 1], VAR_0[i - 2] + A[i])
VAR_0[i] = max(VAR_0[i], A[i])
return VAR_0[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_rename_variable_rn
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
g768962 = [None] * n
g768962[0] = A[0]
g768962[1] = max(A[0], A[1])
for i in range(2, n):
g768962[i] = max(g768962[i - 1], g768962[i - 2] + A[i])
g768962[i] = max(g768962[i], A[i])
return g768962[n - 1]
| 1 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_add_sub_variable
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] - A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 0 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_sub_add_variable
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i + 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 0 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_mul_div_variable
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] / n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 0 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_equalto_exclamation_variable
|
def max_sum_subseq(A):
n = len(A)
if n != 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
| 0 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
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 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
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 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
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 | 892 |
mbpp
|
def max_sum_subseq(A):
n = len(A)
if n == 1:
return A[0]
look_up = [None] * n
look_up[0] = A[0]
look_up[1] = max(A[0], A[1])
for i in range(2, n):
look_up[i] = max(look_up[i - 1], look_up[i - 2] + A[i])
look_up[i] = max(look_up[i], A[i])
return look_up[n - 1]
|
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 | 892 |
mbpp
|
def match_num(string):
import re
text = re.compile(r"^5")
if text.match(string):
return True
else:
return False
|
transformation_dead_code_insert
|
def match_num(string):
import re
text = re.compile(r"^5")
_i_8 = 0
while _i_8 < _i_8:
if text.match(string):
return True
else:
return False
if text.match(string):
return True
else:
return False
| 1 | 897 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.