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 last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_rename_variable_rn
|
def last(arr, x, n):
low = 0
high = n - 1
res = -1
while low <= high:
C5T = (low + high) // 2
if arr[C5T] > x:
high = C5T - 1
elif arr[C5T] < x:
low = C5T + 1
else:
res = C5T
low = C5T + 1
return res
| 1 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_add_sub_variable
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low - high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_sub_add_variable
|
def last(arr,x,n):
low = 0
high = n + 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_div_mul_variable
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) */ 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_lesser_greater_variable
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low >= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_greater_lesser_variable
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] < x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
return res
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
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 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
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 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
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 | 790 |
mbpp
|
def last(arr,x,n):
low = 0
high = n - 1
res = -1
while (low <= high):
mid = (low + high) // 2
if arr[mid] > x:
high = mid - 1
elif arr[mid] < x:
low = mid + 1
else:
res = mid
low = mid + 1
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 | 790 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_dead_code_insert
|
def text_starta_endb(text):
for _i_4 in range(0):
return "Found a match!"
import re
patterns = "a.*?b$"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_for_while_loop
|
def text_starta_endb(text):
import re
patterns = "a.*?b$"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_operand_swap
|
def text_starta_endb(text):
import re
patterns = "a.*?b$"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_naive
|
def text_starta_endb(VAR_0):
import re
patterns = "a.*?b$"
if re.search(patterns, VAR_0):
return "Found a match!"
else:
return "Not matched!"
| 1 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_rn
|
def text_starta_endb(r5vv):
import re
patterns = "a.*?b$"
if re.search(patterns, r5vv):
return "Found a match!"
else:
return "Not matched!"
| 1 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_mul_div_variable
|
def text_starta_endb(text):
import re
patterns = 'a./?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
| 0 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 791 |
mbpp
|
def text_starta_endb(text):
import re
patterns = 'a.*?b$'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 791 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_dead_code_insert
|
def return_sum(dict):
for _i_5 in range(0):
sum = 0
sum = 0
for i in dict.values():
sum = sum + i
return sum
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_for_while_loop
|
def return_sum(dict):
sum = 0
_i_i = 0
while _i_i < len(dict.values()):
i = dict.values()[_i_i]
sum = sum + i
_i_i += 1
return sum
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_operand_swap
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_rename_variable_cb
|
def return_sum(dict):
i2 = 0
for i in dict.values():
i2 = i2 + i
return i2
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_rename_variable_naive
|
def return_sum(dict):
VAR_0 = 0
for i in dict.values():
VAR_0 = VAR_0 + i
return VAR_0
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_rename_variable_rn
|
def return_sum(dict):
wJ1 = 0
for i in dict.values():
wJ1 = wJ1 + i
return wJ1
| 1 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_add_sub_variable
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum - i
return sum
| 0 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
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 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
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 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
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 | 793 |
mbpp
|
def return_sum(dict):
sum = 0
for i in dict.values():
sum = sum + i
return sum
|
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 | 793 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_dead_code_insert
|
def sum_in_Range(l, r):
def sum_Odd(n):
terms = (n + 1) // 2
for _i_9 in range(0):
sum1 = terms * terms
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_for_while_loop
|
def sum_in_Range(l, r):
def sum_Odd(n):
terms = (n + 1) // 2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_operand_swap
|
def sum_in_Range(l, r):
def sum_Odd(n):
terms = (n + 1) // 2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_rename_variable_cb
|
def sum_in_Range(l, r):
def sum_Odd(n):
n2 = (n + 1) // 2
sum1 = n2 * n2
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_rename_variable_naive
|
def sum_in_Range(l, r):
def sum_Odd(n):
VAR_0 = (n + 1) // 2
sum1 = VAR_0 * VAR_0
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_rename_variable_rn
|
def sum_in_Range(l, r):
def sum_Odd(n):
I5uyo = (n + 1) // 2
sum1 = I5uyo * I5uyo
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 1 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_add_sub_variable
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n - 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 0 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_sub_add_variable
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) + sum_Odd(l - 1)
| 0 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_mul_div_variable
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms / terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 0 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_div_mul_variable
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)*/2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
| 0 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 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 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 1)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 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 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 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 | 794 |
mbpp
|
def sum_in_Range(l,r):
def sum_Odd(n):
terms = (n + 1)//2
sum1 = terms * terms
return sum1
return sum_Odd(r) - sum_Odd(l - 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 | 794 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_dead_code_insert
|
def _sum(arr):
sum = 0
if False:
sum = sum + i
for i in arr:
sum = sum + i
return sum
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_for_while_loop
|
def _sum(arr):
sum = 0
_i_i = 0
while _i_i < len(arr):
i = arr[_i_i]
sum = sum + i
_i_i += 1
return sum
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_operand_swap
|
def _sum(arr):
sum = 0
for i in arr:
sum = sum + i
return sum
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_rename_variable_cb
|
def _sum(arr):
split = 0
for i in arr:
split = split + i
return split
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_rename_variable_naive
|
def _sum(arr):
VAR_0 = 0
for i in arr:
VAR_0 = VAR_0 + i
return VAR_0
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_rename_variable_rn
|
def _sum(arr):
pjf = 0
for i in arr:
pjf = pjf + i
return pjf
| 1 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_add_sub_variable
|
def _sum(arr):
sum=0
for i in arr:
sum = sum - i
return(sum)
| 0 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
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 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
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 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
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 | 795 |
mbpp
|
def _sum(arr):
sum=0
for i in arr:
sum = sum + i
return(sum)
|
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 | 795 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_dead_code_insert
|
def remove_all_spaces(text):
_i_0 = 0
while _i_0 < _i_0:
import re
import re
return re.sub(r"s+", "", text)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_for_while_loop
|
def remove_all_spaces(text):
import re
return re.sub(r"s+", "", text)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_operand_swap
|
def remove_all_spaces(text):
import re
return re.sub(r"s+", "", text)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_rename_variable_cb
|
def remove_all_spaces(line):
import re
return re.sub(r"s+", "", line)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_rename_variable_naive
|
def remove_all_spaces(VAR_0):
import re
return re.sub(r"s+", "", VAR_0)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_rename_variable_rn
|
def remove_all_spaces(B2X1):
import re
return re.sub(r"s+", "", B2X1)
| 1 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_add_sub_variable
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s-', '',text))
| 0 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',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 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',text))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',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 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',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 | 797 |
mbpp
|
def remove_all_spaces(text):
import re
return (re.sub(r'\s+', '',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 | 797 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_dead_code_insert
|
def test_three_equal(x, y, z):
while False:
return 0
result = set([x, y, z])
if len(result) == 3:
return 0
else:
return 4 - len(result)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_for_while_loop
|
def test_three_equal(x, y, z):
result = set([x, y, z])
if len(result) == 3:
return 0
else:
return 4 - len(result)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_operand_swap
|
def test_three_equal(x, y, z):
result = set([x, y, z])
if 3 == len(result):
return 0
else:
return 4 - len(result)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_rename_variable_cb
|
def test_three_equal(x, y, z):
set = set([x, y, z])
if len(set) == 3:
return 0
else:
return 4 - len(set)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_rename_variable_naive
|
def test_three_equal(x, y, z):
VAR_0 = set([x, y, z])
if len(VAR_0) == 3:
return 0
else:
return 4 - len(VAR_0)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_rename_variable_rn
|
def test_three_equal(x, y, z):
hx9Ph7 = set([x, y, z])
if len(hx9Ph7) == 3:
return 0
else:
return 4 - len(hx9Ph7)
| 1 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_sub_add_variable
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4+len(result))
| 0 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_equalto_exclamation_variable
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)!=3:
return 0
else:
return (4-len(result))
| 0 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(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 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(result))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(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 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(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 | 798 |
mbpp
|
def test_three_equal(x,y,z):
result= set([x,y,z])
if len(result)==3:
return 0
else:
return (4-len(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 | 798 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_dead_code_insert
|
def first_odd(nums):
while False:
return first_odd
first_odd = next((el for el in nums if el % 2 != 0), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_for_while_loop
|
def first_odd(nums):
first_odd = next((el for el in nums if el % 2 != 0), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_operand_swap
|
def first_odd(nums):
first_odd = next((el for el in nums if 0 != el % 2), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_rename_variable_cb
|
def first_odd(nums):
first_odd = next((i for i in nums if i % 2 != 0), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_rename_variable_naive
|
def first_odd(nums):
first_odd = next((VAR_0 for VAR_0 in nums if VAR_0 % 2 != 0), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_rename_variable_rn
|
def first_odd(nums):
first_odd = next((z5 for z5 in nums if z5 % 2 != 0), -1)
return first_odd
| 1 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_sub_add_variable
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),+1)
return first_odd
| 0 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_exclamation_equalto_variable
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2==0),-1)
return first_odd
| 0 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
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 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
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 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return first_odd
|
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 | 804 |
mbpp
|
def first_odd(nums):
first_odd = next((el for el in nums if el%2!=0),-1)
return 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 | 804 |
mbpp
|
def check_K(test_tup, K):
res = False
for ele in test_tup:
if ele == K:
res = True
break
return (res)
|
transformation_dead_code_insert
|
def check_K(test_tup, K):
_i_2 = 0
if _i_2 < _i_2:
if ele == K:
res = True
break
res = False
for ele in test_tup:
if ele == K:
res = True
break
return res
| 1 | 805 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.