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 get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
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 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
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 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
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 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
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 | 600 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_dead_code_insert
|
def prime_num(num):
if num >= 1:
for i in range(2, num // 2):
_i_8 = 0
if _i_8 > _i_8:
return False
if (num % i) == 0:
return False
else:
return True
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_for_while_loop
|
def prime_num(num):
if num >= 1:
i = 2
while i < num // 2:
if (num % i) == 0:
return False
else:
return True
i += 1
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_operand_swap
|
def prime_num(num):
if 1 <= num:
for i in range(2, num // 2):
if (num % i) == 0:
return False
else:
return True
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_rename_variable_cb
|
def prime_num(n):
if n >= 1:
for i in range(2, n // 2):
if (n % i) == 0:
return False
else:
return True
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_rename_variable_naive
|
def prime_num(VAR_0):
if VAR_0 >= 1:
for i in range(2, VAR_0 // 2):
if (VAR_0 % i) == 0:
return False
else:
return True
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_rename_variable_rn
|
def prime_num(n40):
if n40 >= 1:
for i in range(2, n40 // 2):
if (n40 % i) == 0:
return False
else:
return True
else:
return False
| 1 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_div_mul_variable
|
def prime_num(num):
if num >=1:
for i in range(2, num*/2):
if (num % i) == 0:
return False
else:
return True
else:
return False
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_greater_lesser_variable
|
def prime_num(num):
if num <=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_equalto_exclamation_variable
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) != 0:
return False
else:
return True
else:
return False
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_true_false_variable
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return False
else:
return False
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_false_true_variable
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return True
else:
return True
else:
return False
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
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 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
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 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
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 | 602 |
mbpp
|
def prime_num(num):
if num >=1:
for i in range(2, num//2):
if (num % i) == 0:
return False
else:
return True
else:
return False
|
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 | 602 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_dead_code_insert
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
for _i_8 in range(0):
e = match.end()
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_for_while_loop
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_operand_swap
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_rename_variable_cb
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
s2 = re.search(pattern, text)
s = s2.start()
e = s2.end()
return (s2.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_rename_variable_naive
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
VAR_0 = re.search(pattern, text)
s = VAR_0.start()
e = VAR_0.end()
return (VAR_0.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_rename_variable_rn
|
def find_literals(text, pattern):
import re
pattern = "fox"
text = "The quick brown fox jumps over the lazy dog."
RDXi7 = re.search(pattern, text)
s = RDXi7.start()
e = RDXi7.end()
return (RDXi7.re.pattern, s, e)
| 1 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
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 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
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 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
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 | 604 |
mbpp
|
def find_literals(text, pattern):
import re
pattern = 'fox'
text = 'The quick brown fox jumps over the lazy dog.'
match = re.search(pattern, text)
s = match.start()
e = match.end()
return (match.re.pattern, s, e)
|
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 | 604 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_dead_code_insert
|
def remove_kth_element(list1, L):
return list1[: L - 1] + list1[L:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_for_while_loop
|
def remove_kth_element(list1, L):
return list1[: L - 1] + list1[L:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_operand_swap
|
def remove_kth_element(list1, L):
return list1[: L - 1] + list1[L:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_rename_variable_cb
|
def remove_kth_element(list1, i):
return list1[: i - 1] + list1[i:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_rename_variable_naive
|
def remove_kth_element(list1, VAR_0):
return list1[: VAR_0 - 1] + list1[VAR_0:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_rename_variable_rn
|
def remove_kth_element(VsAX9, L):
return VsAX9[: L - 1] + VsAX9[L:]
| 1 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_add_sub_variable
|
def remove_kth_element(list1, L):
return list1[:L-1] - list1[L:]
| 0 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_sub_add_variable
|
def remove_kth_element(list1, L):
return list1[:L+1] + list1[L:]
| 0 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
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 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
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 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
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 | 607 |
mbpp
|
def remove_kth_element(list1, L):
return list1[:L-1] + list1[L:]
|
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 | 607 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_dead_code_insert
|
def max_of_nth(test_list, N):
_i_8 = 0
if _i_8 < _i_8:
res = max([sub[N] for sub in test_list])
res = max([sub[N] for sub in test_list])
return res
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_for_while_loop
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return res
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_operand_swap
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return res
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_rename_variable_cb
|
def max_of_nth(test_list, N):
N2 = max([sub[N] for sub in test_list])
return N2
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_rename_variable_naive
|
def max_of_nth(VAR_0, N):
res = max([sub[N] for sub in VAR_0])
return res
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
return (res)
|
transformation_rename_variable_rn
|
def max_of_nth(test_list, N):
res = max([J02[N] for J02 in test_list])
return res
| 1 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
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 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
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 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
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 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
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 | 608 |
mbpp
|
def max_of_nth(test_list, N):
res = max([sub[N] for sub in test_list])
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 | 608 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
transformation_mul_div_variable
|
def merge(lst):
return [list(ele) for ele in list(zip(/lst))]
| 0 | 609 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
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 | 609 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 609 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
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 | 609 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
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 | 609 |
mbpp
|
def merge(lst):
return [list(ele) for ele in list(zip(*lst))]
|
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 | 609 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_dead_code_insert
|
def maximum_value(test_list):
_i_5 = 0
if _i_5 < _i_5:
return res
res = [(key, max(lst)) for key, lst in test_list]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_for_while_loop
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_operand_swap
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_rename_variable_cb
|
def maximum_value(test_list):
res = [(test, max(lst)) for test, lst in test_list]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_rename_variable_naive
|
def maximum_value(test_list):
res = [(VAR_0, max(lst)) for VAR_0, lst in test_list]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
return (res)
|
transformation_rename_variable_rn
|
def maximum_value(v9DL35bw1):
res = [(key, max(lst)) for key, lst in v9DL35bw1]
return res
| 1 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
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 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
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 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
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 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
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 | 610 |
mbpp
|
def maximum_value(test_list):
res = [(key, max(lst)) for key, lst in test_list]
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 | 610 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dead_code_insert
|
def average_tuple(nums):
for _i_2 in range(0):
return result
result = [sum(x) / len(x) for x in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_for_while_loop
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_operand_swap
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_rename_variable_cb
|
def average_tuple(nums):
result = [sum(n) / len(n) for n in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_rename_variable_naive
|
def average_tuple(nums):
result = [sum(VAR_0) / len(VAR_0) for VAR_0 in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_rename_variable_rn
|
def average_tuple(nums):
result = [sum(m) / len(m) for m in zip(*nums)]
return result
| 1 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_mul_div_variable
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(/nums)]
return result
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_div_mul_variable
|
def average_tuple(nums):
result = [sum(x) * len(x) for x in zip(*nums)]
return result
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 612 |
mbpp
|
def average_tuple(nums):
result = [sum(x) / len(x) for x in zip(*nums)]
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 612 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_dead_code_insert
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
_i_2 = 0
if _i_2 > _i_2:
b = max(temp, b)
b = max(temp, b)
if d >= b:
return (d + b - 1) / b
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_for_while_loop
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if d >= b:
return (d + b - 1) / b
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_operand_swap
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if b <= d:
return (d + b - 1) / b
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_rename_variable_cb
|
def min_Jumps(a, b2, d):
temp = a
a = min(a, b2)
b2 = max(temp, b2)
if d >= b2:
return (d + b2 - 1) / b2
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_rename_variable_naive
|
def min_Jumps(a, VAR_0, d):
temp = a
a = min(a, VAR_0)
VAR_0 = max(temp, VAR_0)
if d >= VAR_0:
return (d + VAR_0 - 1) / VAR_0
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_rename_variable_rn
|
def min_Jumps(a, R, d):
temp = a
a = min(a, R)
R = max(temp, R)
if d >= R:
return (d + R - 1) / R
if d == 0:
return 0
if d == a:
return 1
else:
return 2
| 1 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_add_sub_variable
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d - b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_sub_add_variable
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b + 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_div_mul_variable
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) * b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_greater_lesser_variable
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d <= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_equalto_exclamation_variable
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d != 0):
return 0
if (d == a):
return 1
else:
return 2
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
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 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 614 |
mbpp
|
def min_Jumps(a, b, d):
temp = a
a = min(a, b)
b = max(temp, b)
if (d >= b):
return (d + b - 1) / b
if (d == 0):
return 0
if (d == a):
return 1
else:
return 2
|
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 | 614 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.