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 pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | transformation_greater_lesser_variable | def pos_count(list):
pos_count= 0
for num in list:
if num <= 0:
pos_count += 1
return pos_count | 0 | 64 | mbpp |
def pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | 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 | 64 | mbpp |
def pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 64 | mbpp |
def pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | 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 | 64 | mbpp |
def pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | 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 | 64 | mbpp |
def pos_count(list):
pos_count= 0
for num in list:
if num >= 0:
pos_count += 1
return pos_count | 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 | 64 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_dead_code_insert | def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
_i_7 = 0
while _i_7 < _i_7:
return "All tuples have same length"
return flag
if find_equal_tuple(Input, k) == 1:
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_for_while_loop | def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
_tuple_i = 0
while _tuple_i < len(Input):
tuple = Input[_tuple_i]
if len(tuple) != k:
flag = 0
break
_tuple_i += 1
return flag
if find_equal_tuple(Input, k) == 1:
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_operand_swap | def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if 1 == find_equal_tuple(Input, k):
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_rename_variable_cb | def get_equal(Input, fi):
def find_equal_tuple(Input, fi):
flag = 1
for tuple in Input:
if len(tuple) != fi:
flag = 0
break
return flag
if find_equal_tuple(Input, fi) == 1:
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_rename_variable_naive | def get_equal(VAR_0, k):
def find_equal_tuple(VAR_0, k):
flag = 1
for tuple in VAR_0:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(VAR_0, k) == 1:
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_rename_variable_rn | def get_equal(wW2N9, k):
def find_equal_tuple(wW2N9, k):
flag = 1
for tuple in wW2N9:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(wW2N9, k) == 1:
return "All tuples have same length"
else:
return "All tuples do not have same length" | 1 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_equalto_exclamation_variable | def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) != 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 0 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_exclamation_equalto_variable | def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) == k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 0 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 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 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 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 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 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 | 68 | mbpp |
def get_equal(Input, k):
def find_equal_tuple(Input, k):
flag = 1
for tuple in Input:
if len(tuple) != k:
flag = 0
break
return flag
if find_equal_tuple(Input, k) == 1:
return ("All tuples have same length")
else:
return ("All tuples do not have same length") | 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 | 68 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | transformation_mul_div_variable | def multiple_split(text):
import re
return (re.split('; |, |\/|\n',text)) | 0 | 71 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | 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 | 71 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 71 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | 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 | 71 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | 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 | 71 | mbpp |
def multiple_split(text):
import re
return (re.split('; |, |\*|\n',text)) | 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 | 71 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | transformation_dead_code_insert | def is_Diff(n):
_i_4 = 0
if _i_4 > _i_4:
return n % 11 == 0
return n % 11 == 0 | 1 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | transformation_equalto_exclamation_variable | def is_Diff(n):
return (n % 11 != 0) | 0 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | 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 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | 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 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | 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 | 75 | mbpp |
def is_Diff(n):
return (n % 11 == 0) | 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 | 75 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_dead_code_insert | def volume_sphere(r):
_i_3 = 0
if _i_3 > _i_3:
return volume
import math
volume = (4 / 3) * math.pi * r * r * r
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_for_while_loop | def volume_sphere(r):
import math
volume = (4 / 3) * math.pi * r * r * r
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_operand_swap | def volume_sphere(r):
import math
volume = (4 / 3) * math.pi * r * r * r
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_rename_variable_cb | def volume_sphere(pi2):
import math
volume = (4 / 3) * math.pi * pi2 * pi2 * pi2
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_rename_variable_naive | def volume_sphere(VAR_0):
import math
volume = (4 / 3) * math.pi * VAR_0 * VAR_0 * VAR_0
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_rename_variable_rn | def volume_sphere(H):
import math
volume = (4 / 3) * math.pi * H * H * H
return volume | 1 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_mul_div_variable | def volume_sphere(r):
import math
volume=(4/3)/math.pi*r*r*r
return volume | 0 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_div_mul_variable | def volume_sphere(r):
import math
volume=(4*3)*math.pi*r*r*r
return volume | 0 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | 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 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | 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 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | 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 | 80 | mbpp |
def volume_sphere(r):
import math
volume=(4/3)*math.pi*r*r*r
return volume | 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 | 80 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_dead_code_insert | def merge_dictionaries_three(dict1, dict2, dict3):
if False:
merged_dict = dict(ct.ChainMap({}, dict1, dict2, dict3))
import collections as ct
merged_dict = dict(ct.ChainMap({}, dict1, dict2, dict3))
return merged_dict | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_for_while_loop | def merge_dictionaries_three(dict1, dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({}, dict1, dict2, dict3))
return merged_dict | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_operand_swap | def merge_dictionaries_three(dict1, dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({}, dict1, dict2, dict3))
return merged_dict | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_rename_variable_cb | def merge_dictionaries_three(dict1, keys, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({}, dict1, keys, dict3))
return merged_dict | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_rename_variable_naive | def merge_dictionaries_three(dict1, VAR_0, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({}, dict1, VAR_0, dict3))
return merged_dict | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_rename_variable_rn | def merge_dictionaries_three(dict1, dict2, dict3):
import collections as ct
kKK102I566Q = dict(ct.ChainMap({}, dict1, dict2, dict3))
return kKK102I566Q | 1 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | 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 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | 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 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | 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 | 85 | mbpp |
def merge_dictionaries_three(dict1,dict2, dict3):
import collections as ct
merged_dict = dict(ct.ChainMap({},dict1,dict2,dict3))
return merged_dict | 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 | 85 | mbpp |
def closest_num(N):
return (N - 1) | transformation_dead_code_insert | def closest_num(N):
for _i_5 in range(0):
return N - 1
return N - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_for_while_loop | def closest_num(N):
return N - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_operand_swap | def closest_num(N):
return N - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_rename_variable_cb | def closest_num(line):
return line - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_rename_variable_naive | def closest_num(VAR_0):
return VAR_0 - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_rename_variable_rn | def closest_num(Q):
return Q - 1 | 1 | 87 | mbpp |
def closest_num(N):
return (N - 1) | transformation_sub_add_variable | def closest_num(N):
return (N + 1) | 0 | 87 | mbpp |
def closest_num(N):
return (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 | 87 | mbpp |
def closest_num(N):
return (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 | 87 | mbpp |
def closest_num(N):
return (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 | 87 | mbpp |
def closest_num(N):
return (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 | 87 | mbpp |
def closest_num(N):
return (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 | 87 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_dead_code_insert | def power(a, b):
if b == 0:
return 1
elif a == 0:
for _i_7 in range(0):
return a * power(a, b - 1)
return 0
elif b == 1:
return a
else:
return a * power(a, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_for_while_loop | def power(a, b):
if b == 0:
return 1
elif a == 0:
return 0
elif b == 1:
return a
else:
return a * power(a, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_operand_swap | def power(a, b):
if 0 == b:
return 1
elif a == 0:
return 0
elif b == 1:
return a
else:
return a * power(a, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_rename_variable_cb | def power(b2, b):
if b == 0:
return 1
elif b2 == 0:
return 0
elif b == 1:
return b2
else:
return b2 * power(b2, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_rename_variable_naive | def power(VAR_0, b):
if b == 0:
return 1
elif VAR_0 == 0:
return 0
elif b == 1:
return VAR_0
else:
return VAR_0 * power(VAR_0, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_rename_variable_rn | def power(T, b):
if b == 0:
return 1
elif T == 0:
return 0
elif b == 1:
return T
else:
return T * power(T, b - 1) | 1 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_sub_add_variable | def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b+1) | 0 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_mul_div_variable | def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a/power(a,b-1) | 0 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_equalto_exclamation_variable | def power(a,b):
if b!=0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | 0 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-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 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-1) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-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 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-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 | 91 | mbpp |
def power(a,b):
if b==0:
return 1
elif a==0:
return 0
elif b==1:
return a
else:
return a*power(a,b-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 | 91 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | transformation_dead_code_insert | def Find_Min_Length(lst):
for _i_1 in range(0):
return minLength
minLength = min(len(x) for x in lst)
return minLength | 1 | 93 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | 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 | 93 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 93 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | 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 | 93 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | 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 | 93 | mbpp |
def Find_Min_Length(lst):
minLength = min(len(x) for x in lst )
return minLength | 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 | 93 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_dead_code_insert | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
for _i_3 in range(0):
dic_data[num] += 1
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_for_while_loop | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
_num_i = 0
while _num_i < len(list1):
num = list1[_num_i]
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
_num_i += 1
return dic_data | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_operand_swap | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_rename_variable_cb | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
result = {}
for num in list1:
if num in result.keys():
result[num] += 1
else:
key = num
value = 1
result[key] = value
return result | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_rename_variable_naive | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
VAR_0 = {}
for num in list1:
if num in VAR_0.keys():
VAR_0[num] += 1
else:
key = num
value = 1
VAR_0[key] = value
return VAR_0 | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_rename_variable_rn | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
VC38d3cA = {}
for num in list1:
if num in VC38d3cA.keys():
VC38d3cA[num] += 1
else:
key = num
value = 1
VC38d3cA[key] = value
return VC38d3cA | 1 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_add_sub_variable | def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] -= 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 0 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 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 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 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 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 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 | 95 | mbpp |
def frequency_lists(list1):
list1 = [item for sublist in list1 for item in sublist]
dic_data = {}
for num in list1:
if num in dic_data.keys():
dic_data[num] += 1
else:
key = num
value = 1
dic_data[key] = value
return dic_data | 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 | 95 | mbpp |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.