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 binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
transformation_equalto_exclamation_variable
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] != item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
| 0 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
transformation_true_false_variable
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = False
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
| 0 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
transformation_false_true_variable
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = True
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
| 0 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
transformation_and_or_variable
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last or not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
| 0 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
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 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
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 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
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 | 489 |
mbpp
|
def binary_search(item_list,item):
first = 0
last = len(item_list)-1
found = False
while( first<=last and not found):
mid = (first + last)//2
if item_list[mid] == item :
found = True
else:
if item < item_list[mid]:
last = mid - 1
else:
first = mid + 1
return found
|
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 | 489 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dead_code_insert
|
def binary_to_integer(test_tup):
for _i_8 in range(0):
return str(res)
res = int("".join(str(ele) for ele in test_tup), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_for_while_loop
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_operand_swap
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_rename_variable_cb
|
def binary_to_integer(b):
res = int("".join(str(ele) for ele in b), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_rename_variable_naive
|
def binary_to_integer(test_tup):
res = int("".join(str(VAR_0) for VAR_0 in test_tup), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_rename_variable_rn
|
def binary_to_integer(u6255R8M):
res = int("".join(str(ele) for ele in u6255R8M), 2)
return str(res)
| 1 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 491 |
mbpp
|
def binary_to_integer(test_tup):
res = int("".join(str(ele) for ele in test_tup), 2)
return (str(res))
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 491 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dead_code_insert
|
def remove_lowercase(str1):
for _i_3 in range(0):
remove_lower = lambda text: re.sub("[a-z]", "", text)
import re
remove_lower = lambda text: re.sub("[a-z]", "", text)
result = remove_lower(str1)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_for_while_loop
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub("[a-z]", "", text)
result = remove_lower(str1)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_operand_swap
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub("[a-z]", "", text)
result = remove_lower(str1)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_rename_variable_cb
|
def remove_lowercase(text2):
import re
remove_lower = lambda text: re.sub("[a-z]", "", text)
result = remove_lower(text2)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_rename_variable_naive
|
def remove_lowercase(VAR_0):
import re
remove_lower = lambda text: re.sub("[a-z]", "", text)
result = remove_lower(VAR_0)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_rename_variable_rn
|
def remove_lowercase(str1):
import re
remove_lower = lambda o0Fn: re.sub("[a-z]", "", o0Fn)
result = remove_lower(str1)
return result
| 1 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_sub_add_variable
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a+z]', '', text)
result = remove_lower(str1)
return (result)
| 0 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 492 |
mbpp
|
def remove_lowercase(str1):
import re
remove_lower = lambda text: re.sub('[a-z]', '', text)
result = remove_lower(str1)
return (result)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 492 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_dead_code_insert
|
def diameter_circle(r):
for _i_0 in range(0):
return diameter
diameter = 2 * r
return diameter
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_for_while_loop
|
def diameter_circle(r):
diameter = 2 * r
return diameter
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_operand_swap
|
def diameter_circle(r):
diameter = 2 * r
return diameter
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_rename_variable_cb
|
def diameter_circle(p):
diameter = 2 * p
return diameter
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_rename_variable_naive
|
def diameter_circle(r):
VAR_0 = 2 * r
return VAR_0
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_rename_variable_rn
|
def diameter_circle(r):
lu1QLlp3 = 2 * r
return lu1QLlp3
| 1 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_mul_div_variable
|
def diameter_circle(r):
diameter=2/r
return diameter
| 0 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
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 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
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 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
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 | 496 |
mbpp
|
def diameter_circle(r):
diameter=2*r
return diameter
|
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 | 496 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dead_code_insert
|
def num_comm_div(x, y):
def ngcd(x, y):
i = 1
if False:
if x % i == 0 and y % i == 0:
gcd = i
while i <= x and i <= y:
if x % i == 0 and y % i == 0:
gcd = i
i += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
i = 1
while i <= z:
if n % i == 0:
result += 2
if i == n / i:
result -= 1
i += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_for_while_loop
|
def num_comm_div(x, y):
def ngcd(x, y):
i = 1
while i <= x and i <= y:
if x % i == 0 and y % i == 0:
gcd = i
i += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
i = 1
while i <= z:
if n % i == 0:
result += 2
if i == n / i:
result -= 1
i += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_operand_swap
|
def num_comm_div(x, y):
def ngcd(x, y):
i = 1
while i <= x and i <= y:
if x % i == 0 and y % i == 0:
gcd = i
i += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
i = 1
while z >= i:
if n % i == 0:
result += 2
if i == n / i:
result -= 1
i += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_rename_variable_cb
|
def num_comm_div(x, y):
def ngcd(x, y):
n2 = 1
while n2 <= x and n2 <= y:
if x % n2 == 0 and y % n2 == 0:
gcd = n2
n2 += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
n2 = 1
while n2 <= z:
if n % n2 == 0:
result += 2
if n2 == n / n2:
result -= 1
n2 += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_rename_variable_naive
|
def num_comm_div(x, y):
def ngcd(x, y):
VAR_0 = 1
while VAR_0 <= x and VAR_0 <= y:
if x % VAR_0 == 0 and y % VAR_0 == 0:
gcd = VAR_0
VAR_0 += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
VAR_0 = 1
while VAR_0 <= z:
if n % VAR_0 == 0:
result += 2
if VAR_0 == n / VAR_0:
result -= 1
VAR_0 += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_rename_variable_rn
|
def num_comm_div(x, y):
def ngcd(x, y):
I = 1
while I <= x and I <= y:
if x % I == 0 and y % I == 0:
gcd = I
I += 1
return gcd
n = ngcd(x, y)
result = 0
z = int(n ** 0.5)
I = 1
while I <= z:
if n % I == 0:
result += 2
if I == n / I:
result -= 1
I += 1
return result
| 1 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_add_sub_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i-=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_sub_add_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result+=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_mul_div_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n/*0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_div_mul_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n*i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_lesser_greater_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i>=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_equalto_exclamation_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i!=0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_and_or_variable
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x or i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 498 |
mbpp
|
def num_comm_div(x,y):
def ngcd(x,y):
i=1
while(i<=x and i<=y):
if(x%i==0 and y%i == 0):
gcd=i;
i+=1
return gcd;
n = ngcd(x,y)
result = 0
z = int(n**0.5)
i = 1
while(i <= z):
if(n % i == 0):
result += 2
if(i == n/i):
result-=1
i+=1
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 498 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_dead_code_insert
|
def find(n, m):
_i_7 = 0
while _i_7 < _i_7:
r = n % m
r = n % m
return r
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_for_while_loop
|
def find(n, m):
r = n % m
return r
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_operand_swap
|
def find(n, m):
r = n % m
return r
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_rename_variable_cb
|
def find(n, m):
p = n % m
return p
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_rename_variable_naive
|
def find(n, VAR_0):
r = n % VAR_0
return r
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_rename_variable_rn
|
def find(n, m):
y = n % m
return y
| 1 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
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 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
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 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
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 | 499 |
mbpp
|
def find(n,m):
r = n%m
return (r)
|
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 | 499 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dead_code_insert
|
def add_consecutive_nums(nums):
for _i_3 in range(0):
return result
result = [b + a for a, b in zip(nums[:-1], nums[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_for_while_loop
|
def add_consecutive_nums(nums):
result = [b + a for a, b in zip(nums[:-1], nums[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_operand_swap
|
def add_consecutive_nums(nums):
result = [b + a for a, b in zip(nums[:-1], nums[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_rename_variable_cb
|
def add_consecutive_nums(line):
result = [b + a for a, b in zip(line[:-1], line[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_rename_variable_naive
|
def add_consecutive_nums(VAR_0):
result = [b + a for a, b in zip(VAR_0[:-1], VAR_0[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_rename_variable_rn
|
def add_consecutive_nums(iu52):
result = [b + a for a, b in zip(iu52[:-1], iu52[1:])]
return result
| 1 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_add_sub_variable
|
def add_consecutive_nums(nums):
result = [b-a for a, b in zip(nums[:-1], nums[1:])]
return result
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_sub_add_variable
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:+1], nums[1:])]
return result
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 500 |
mbpp
|
def add_consecutive_nums(nums):
result = [b+a for a, b in zip(nums[:-1], nums[1:])]
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 500 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_dead_code_insert
|
def re_order(A):
k = 0
for i in A:
if i:
while False:
k = k + 1
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_for_while_loop
|
def re_order(A):
k = 0
_i_i = 0
while _i_i < len(A):
i = A[_i_i]
if i:
A[k] = i
k = k + 1
_i_i += 1
for i in range(k, len(A)):
A[i] = 0
return A
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_operand_swap
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_rename_variable_cb
|
def re_order(lines):
k = 0
for i in lines:
if i:
lines[k] = i
k = k + 1
for i in range(k, len(lines)):
lines[i] = 0
return lines
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_rename_variable_naive
|
def re_order(VAR_0):
k = 0
for i in VAR_0:
if i:
VAR_0[k] = i
k = k + 1
for i in range(k, len(VAR_0)):
VAR_0[i] = 0
return VAR_0
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_rename_variable_rn
|
def re_order(K):
k = 0
for i in K:
if i:
K[k] = i
k = k + 1
for i in range(k, len(K)):
K[i] = 0
return K
| 1 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_add_sub_variable
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k - 1
for i in range(k, len(A)):
A[i] = 0
return A
| 0 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
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 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
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 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
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 | 502 |
mbpp
|
def re_order(A):
k = 0
for i in A:
if i:
A[k] = i
k = k + 1
for i in range(k, len(A)):
A[i] = 0
return A
|
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 | 502 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_dead_code_insert
|
def permutation_coefficient(n, k):
_i_7 = 0
if _i_7 > _i_7:
P[i][j] = 1
P = [[0 for i in range(k + 1)] for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if j == 0:
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (j * P[i - 1][j - 1])
if j < k:
P[i][j + 1] = 0
return P[n][k]
| 1 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_for_while_loop
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)] for j in range(n + 1)]
i = 0
while i < n + 1:
for j in range(min(i, k) + 1):
if j == 0:
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (j * P[i - 1][j - 1])
if j < k:
P[i][j + 1] = 0
i += 1
return P[n][k]
| 1 | 503 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.