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-... | 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-... | 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-... | 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 | 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 | 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 | 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 | 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-... | 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-... | 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-... | 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-... | 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-... | 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 su... | 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 su... | 1 | 445 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.