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-... | 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()) == sort... | 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):
... | 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()) == sort... | 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... | 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()) == sort... | 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... | 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()) == sort... | 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()):
... | 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()) == sort... | 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... | 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()) == sort... | 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... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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()) != sort... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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-... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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()) == sort... | 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-... | 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-... | 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-... | 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-... | 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-... | 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])
lo... | 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 loo... | 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-... | 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.