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 parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
transformation_dead_code_insert
|
def parabola_directrix(a, b, c):
if False:
return directrix
directrix = (int)(c - ((b * b) + 1) * 4 * a)
return directrix
| 1 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
transformation_add_sub_variable
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) - 1) * 4 * a ))
return directrix
| 0 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
transformation_sub_add_variable
|
def parabola_directrix(a, b, c):
directrix=((int)(c + ((b * b) + 1) * 4 * a ))
return directrix
| 0 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
transformation_mul_div_variable
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b / b) + 1) * 4 * a ))
return directrix
| 0 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
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 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
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 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
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 | 427 |
mbpp
|
def parabola_directrix(a, b, c):
directrix=((int)(c - ((b * b) + 1) * 4 * a ))
return directrix
|
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 | 427 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_dead_code_insert
|
def text_match_one(text):
import re
patterns = "ab+?"
while False:
import re
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_for_while_loop
|
def text_match_one(text):
import re
patterns = "ab+?"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_operand_swap
|
def text_match_one(text):
import re
patterns = "ab+?"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_naive
|
def text_match_one(VAR_0):
import re
patterns = "ab+?"
if re.search(patterns, VAR_0):
return "Found a match!"
else:
return "Not matched!"
| 1 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_rn
|
def text_match_one(J569):
import re
patterns = "ab+?"
if re.search(patterns, J569):
return "Found a match!"
else:
return "Not matched!"
| 1 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_add_sub_variable
|
def text_match_one(text):
import re
patterns = 'ab-?'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
| 0 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
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 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
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 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
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 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
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 | 431 |
mbpp
|
def text_match_one(text):
import re
patterns = 'ab+?'
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 | 431 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_dead_code_insert
|
def remove_odd(str1):
_i_7 = 0
while _i_7 < _i_7:
if i % 2 == 0:
str2 = str2 + str1[i - 1]
str2 = ""
for i in range(1, len(str1) + 1):
if i % 2 == 0:
str2 = str2 + str1[i - 1]
return str2
| 1 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_for_while_loop
|
def remove_odd(str1):
str2 = ""
i = 1
while i < len(str1) + 1:
if i % 2 == 0:
str2 = str2 + str1[i - 1]
i += 1
return str2
| 1 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_operand_swap
|
def remove_odd(str1):
str2 = ""
for i in range(1, len(str1) + 1):
if 0 == i % 2:
str2 = str2 + str1[i - 1]
return str2
| 1 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_rename_variable_naive
|
def remove_odd(str1):
VAR_0 = ""
for i in range(1, len(str1) + 1):
if i % 2 == 0:
VAR_0 = VAR_0 + str1[i - 1]
return VAR_0
| 1 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_rename_variable_rn
|
def remove_odd(str1):
iw6p = ""
for i in range(1, len(str1) + 1):
if i % 2 == 0:
iw6p = iw6p + str1[i - 1]
return iw6p
| 1 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_add_sub_variable
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) - 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
| 0 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_sub_add_variable
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i + 1]
return str2
| 0 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_equalto_exclamation_variable
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 != 0):
str2 = str2 + str1[i - 1]
return str2
| 0 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
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 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
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 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
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 | 434 |
mbpp
|
def remove_odd(str1):
str2 = ''
for i in range(1, len(str1) + 1):
if(i % 2 == 0):
str2 = str2 + str1[i - 1]
return str2
|
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 | 434 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_dead_code_insert
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
_i_5 = 0
while _i_5 < _i_5:
res = 0
for iidx in range(idx + 1, len(test_list)):
if (
test_list[iidx][0] == test_list[idx][1]
and test_list[idx][1] == test_list[iidx][0]
):
res += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_for_while_loop
|
def count_bidirectional(test_list):
res = 0
idx = 0
while idx < len(test_list):
for iidx in range(idx + 1, len(test_list)):
if (
test_list[iidx][0] == test_list[idx][1]
and test_list[idx][1] == test_list[iidx][0]
):
res += 1
idx += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_operand_swap
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if (
test_list[idx][1] == test_list[iidx][0]
and test_list[idx][1] == test_list[iidx][0]
):
res += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_rename_variable_cb
|
def count_bidirectional(i):
res = 0
for idx in range(0, len(i)):
for iidx in range(idx + 1, len(i)):
if i[iidx][0] == i[idx][1] and i[idx][1] == i[iidx][0]:
res += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_rename_variable_naive
|
def count_bidirectional(VAR_0):
res = 0
for idx in range(0, len(VAR_0)):
for iidx in range(idx + 1, len(VAR_0)):
if VAR_0[iidx][0] == VAR_0[idx][1] and VAR_0[idx][1] == VAR_0[iidx][0]:
res += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_rename_variable_rn
|
def count_bidirectional(M7e1xd770):
res = 0
for idx in range(0, len(M7e1xd770)):
for iidx in range(idx + 1, len(M7e1xd770)):
if (
M7e1xd770[iidx][0] == M7e1xd770[idx][1]
and M7e1xd770[idx][1] == M7e1xd770[iidx][0]
):
res += 1
return str(res)
| 1 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_add_sub_variable
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx - 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
| 0 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_equalto_exclamation_variable
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] != test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
| 0 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
|
transformation_and_or_variable
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] or test_list[idx][1] == test_list[iidx][0]:
res += 1
return (str(res))
| 0 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
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 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
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 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
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 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
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 | 435 |
mbpp
|
def count_bidirectional(test_list):
res = 0
for idx in range(0, len(test_list)):
for iidx in range(idx + 1, len(test_list)):
if test_list[iidx][0] == test_list[idx][1] and test_list[idx][1] == test_list[iidx][0]:
res += 1
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 | 435 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_dead_code_insert
|
def find_adverb_position(text):
import re
if False:
import re
for m in re.finditer(r"w+ly", text):
return (m.start(), m.end(), m.group(0))
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_for_while_loop
|
def find_adverb_position(text):
import re
_m_i = 0
while _m_i < len(re.finditer(r"w+ly", text)):
m = re.finditer(r"w+ly", text)[_m_i]
return (m.start(), m.end(), m.group(0))
_m_i += 1
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_operand_swap
|
def find_adverb_position(text):
import re
for m in re.finditer(r"w+ly", text):
return (m.start(), m.end(), m.group(0))
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_rename_variable_cb
|
def find_adverb_position(text):
import re
for m2 in re.finditer(r"w+ly", text):
return (m2.start(), m2.end(), m2.group(0))
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_rename_variable_naive
|
def find_adverb_position(text):
import re
for VAR_0 in re.finditer(r"w+ly", text):
return (VAR_0.start(), VAR_0.end(), VAR_0.group(0))
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_rename_variable_rn
|
def find_adverb_position(text):
import re
for U in re.finditer(r"w+ly", text):
return (U.start(), U.end(), U.group(0))
| 1 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_add_sub_variable
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w-ly", text):
return (m.start(), m.end(), m.group(0))
| 0 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(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 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(0))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(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 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(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 | 437 |
mbpp
|
def find_adverb_position(text):
import re
for m in re.finditer(r"\w+ly", text):
return (m.start(), m.end(), m.group(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 | 437 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_dead_code_insert
|
def surfacearea_cube(l):
while False:
surfacearea = 6 * l * l
surfacearea = 6 * l * l
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_for_while_loop
|
def surfacearea_cube(l):
surfacearea = 6 * l * l
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_operand_swap
|
def surfacearea_cube(l):
surfacearea = 6 * l * l
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_rename_variable_cb
|
def surfacearea_cube(first):
surfacearea = 6 * first * first
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_rename_variable_naive
|
def surfacearea_cube(VAR_0):
surfacearea = 6 * VAR_0 * VAR_0
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_rename_variable_rn
|
def surfacearea_cube(v):
surfacearea = 6 * v * v
return surfacearea
| 1 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_mul_div_variable
|
def surfacearea_cube(l):
surfacearea= 6/l*l
return surfacearea
| 0 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
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 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
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 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
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 | 438 |
mbpp
|
def surfacearea_cube(l):
surfacearea= 6*l*l
return surfacearea
|
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 | 438 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_dead_code_insert
|
def trim_tuple(test_list, K):
if False:
res.append(tuple(list(ele)[K : N - K]))
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K : N - K]))
return str(res)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_for_while_loop
|
def trim_tuple(test_list, K):
res = []
_ele_i = 0
while _ele_i < len(test_list):
ele = test_list[_ele_i]
N = len(ele)
res.append(tuple(list(ele)[K : N - K]))
_ele_i += 1
return str(res)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_operand_swap
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K : N - K]))
return str(res)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_rename_variable_cb
|
def trim_tuple(test_list, K):
ele2 = []
for ele in test_list:
N = len(ele)
ele2.append(tuple(list(ele)[K : N - K]))
return str(ele2)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_rename_variable_naive
|
def trim_tuple(test_list, VAR_0):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[VAR_0 : N - VAR_0]))
return str(res)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_rename_variable_rn
|
def trim_tuple(test_list, K):
pT1 = []
for ele in test_list:
N = len(ele)
pT1.append(tuple(list(ele)[K : N - K]))
return str(pT1)
| 1 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
return (str(res))
|
transformation_sub_add_variable
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N + K]))
return (str(res))
| 0 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
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 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
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 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
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 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
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 | 441 |
mbpp
|
def trim_tuple(test_list, K):
res = []
for ele in test_list:
N = len(ele)
res.append(tuple(list(ele)[K: N - K]))
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 | 441 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_dead_code_insert
|
def count_Occurrence(tup, lst):
from collections import Counter
_i_5 = 0
while _i_5 < _i_5:
count += 1
count = 0
for item in tup:
if item in lst:
count += 1
return count
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_for_while_loop
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
_item_i = 0
while _item_i < len(tup):
item = tup[_item_i]
if item in lst:
count += 1
_item_i += 1
return count
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_operand_swap
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count += 1
return count
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_rename_variable_cb
|
def count_Occurrence(tup, lst):
from collections import Counter
counter = 0
for item in tup:
if item in lst:
counter += 1
return counter
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_rename_variable_naive
|
def count_Occurrence(tup, lst):
from collections import Counter
VAR_0 = 0
for item in tup:
if item in lst:
VAR_0 += 1
return VAR_0
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_rename_variable_rn
|
def count_Occurrence(tup, lst):
from collections import Counter
cM56B = 0
for item in tup:
if item in lst:
cM56B += 1
return cM56B
| 1 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_add_sub_variable
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count-= 1
return count
| 0 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return 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 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return count
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return 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 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return 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 | 443 |
mbpp
|
def count_Occurrence(tup, lst):
from collections import Counter
count = 0
for item in tup:
if item in lst:
count+= 1
return 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 | 443 |
mbpp
|
def cal_sum(n):
a = 3
b = 0
c = 2
if (n == 0):
return 3
if (n == 1):
return 3
if (n == 2):
return 5
sum = 5
while (n > 2):
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n-1
return sum
|
transformation_dead_code_insert
|
def cal_sum(n):
a = 3
b = 0
c = 2
if n == 0:
return 3
if n == 1:
return 3
if False:
a = 3
if n == 2:
return 5
sum = 5
while n > 2:
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n - 1
return sum
| 1 | 445 |
mbpp
|
def cal_sum(n):
a = 3
b = 0
c = 2
if (n == 0):
return 3
if (n == 1):
return 3
if (n == 2):
return 5
sum = 5
while (n > 2):
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n-1
return sum
|
transformation_for_while_loop
|
def cal_sum(n):
a = 3
b = 0
c = 2
if n == 0:
return 3
if n == 1:
return 3
if n == 2:
return 5
sum = 5
while n > 2:
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n - 1
return sum
| 1 | 445 |
mbpp
|
def cal_sum(n):
a = 3
b = 0
c = 2
if (n == 0):
return 3
if (n == 1):
return 3
if (n == 2):
return 5
sum = 5
while (n > 2):
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n-1
return sum
|
transformation_operand_swap
|
def cal_sum(n):
a = 3
b = 0
c = 2
if 0 == n:
return 3
if n == 1:
return 3
if n == 2:
return 5
sum = 5
while n > 2:
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n - 1
return sum
| 1 | 445 |
mbpp
|
def cal_sum(n):
a = 3
b = 0
c = 2
if (n == 0):
return 3
if (n == 1):
return 3
if (n == 2):
return 5
sum = 5
while (n > 2):
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n-1
return sum
|
transformation_rename_variable_cb
|
def cal_sum(ve):
a = 3
b = 0
c = 2
if ve == 0:
return 3
if ve == 1:
return 3
if ve == 2:
return 5
sum = 5
while ve > 2:
d = a + b
sum = sum + d
a = b
b = c
c = d
ve = ve - 1
return sum
| 1 | 445 |
mbpp
|
def cal_sum(n):
a = 3
b = 0
c = 2
if (n == 0):
return 3
if (n == 1):
return 3
if (n == 2):
return 5
sum = 5
while (n > 2):
d = a + b
sum = sum + d
a = b
b = c
c = d
n = n-1
return sum
|
transformation_rename_variable_naive
|
def cal_sum(VAR_0):
a = 3
b = 0
c = 2
if VAR_0 == 0:
return 3
if VAR_0 == 1:
return 3
if VAR_0 == 2:
return 5
sum = 5
while VAR_0 > 2:
d = a + b
sum = sum + d
a = b
b = c
c = d
VAR_0 = VAR_0 - 1
return sum
| 1 | 445 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.