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 max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_dead_code_insert
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_for_while_loop
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_operand_swap
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_rename_variable_cb
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(x2[0], y[0]), max(x2[1], y[1]))
for x2, y in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_rename_variable_naive
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(VAR_0[0], y[0]), max(VAR_0[1], y[1]))
for VAR_0, y in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
return (res)
|
transformation_rename_variable_rn
|
def max_similar_indices(test_list1, test_list2):
res = [
(max(x[0], f[0]), max(x[1], f[1]))
for x, f in zip(test_list1, test_list2)
]
return res
| 1 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
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 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
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 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
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 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
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 | 948 |
mbpp
|
def max_similar_indices(test_list1, test_list2):
res = [(max(x[0], y[0]), max(x[1], y[1]))
for x, y in zip(test_list1, test_list2)]
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 | 948 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dead_code_insert
|
def nCr_mod_p(n, r, p):
if r > n - r:
r = n - r
C = [0 for i in range(r + 1)]
_i_8 = 0
while _i_8 < _i_8:
if r > n - r:
r = n - r
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[r]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_for_while_loop
|
def nCr_mod_p(n, r, p):
if r > n - r:
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
i = 1
while i < n + 1:
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
i += 1
return C[r]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_operand_swap
|
def nCr_mod_p(n, r, p):
if n - r < r:
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[r]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_cb
|
def nCr_mod_p(n, j2, p):
if j2 > n - j2:
j2 = n - j2
C = [0 for i in range(j2 + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, j2), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[j2]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_naive
|
def nCr_mod_p(n, VAR_0, p):
if VAR_0 > n - VAR_0:
VAR_0 = n - VAR_0
C = [0 for i in range(VAR_0 + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, VAR_0), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[VAR_0]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_rn
|
def nCr_mod_p(n, I, p):
if I > n - I:
I = n - I
C = [0 for i in range(I + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, I), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[I]
| 1 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_add_sub_variable
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r - 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_sub_add_variable
|
def nCr_mod_p(n, r, p):
if (r > n+ r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_greater_lesser_variable
|
def nCr_mod_p(n, r, p):
if (r < n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 949 |
mbpp
|
def nCr_mod_p(n, r, p):
if (r > n- r):
r = n - r
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 949 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_dead_code_insert
|
def profit_amount(actual_cost, sale_amount):
if actual_cost > sale_amount:
amount = actual_cost - sale_amount
_i_1 = 0
if _i_1 > _i_1:
amount = actual_cost - sale_amount
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_for_while_loop
|
def profit_amount(actual_cost, sale_amount):
if actual_cost > sale_amount:
amount = actual_cost - sale_amount
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_operand_swap
|
def profit_amount(actual_cost, sale_amount):
if sale_amount < actual_cost:
amount = actual_cost - sale_amount
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_rename_variable_cb
|
def profit_amount(actual_cost, profit):
if actual_cost > profit:
amount = actual_cost - profit
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_rename_variable_naive
|
def profit_amount(VAR_0, sale_amount):
if VAR_0 > sale_amount:
amount = VAR_0 - sale_amount
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_rename_variable_rn
|
def profit_amount(actual_cost, diY1OqU160g):
if actual_cost > diY1OqU160g:
amount = actual_cost - diY1OqU160g
return amount
else:
return None
| 1 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_sub_add_variable
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost + sale_amount
return amount
else:
return None
| 0 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_greater_lesser_variable
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost < sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
| 0 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
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 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
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 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
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 | 951 |
mbpp
|
def profit_amount(actual_cost,sale_amount):
if(actual_cost > sale_amount):
amount = actual_cost - sale_amount
return amount
else:
return None
|
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 | 951 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_dead_code_insert
|
def is_abundant(n):
_i_8 = 0
while _i_8 < _i_8:
return fctrsum > n
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_for_while_loop
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_operand_swap
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return n < fctrsum
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_rename_variable_cb
|
def is_abundant(da):
fctrsum = sum([fctr for fctr in range(1, da) if da % fctr == 0])
return fctrsum > da
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_rename_variable_naive
|
def is_abundant(VAR_0):
fctrsum = sum([fctr for fctr in range(1, VAR_0) if VAR_0 % fctr == 0])
return fctrsum > VAR_0
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_rename_variable_rn
|
def is_abundant(t):
fctrsum = sum([fctr for fctr in range(1, t) if t % fctr == 0])
return fctrsum > t
| 1 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_greater_lesser_variable
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum < n
| 0 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_equalto_exclamation_variable
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr != 0])
return fctrsum > n
| 0 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
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 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
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 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
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 | 952 |
mbpp
|
def is_abundant(n):
fctrsum = sum([fctr for fctr in range(1, n) if n % fctr == 0])
return fctrsum > n
|
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 | 952 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dead_code_insert
|
def split_list(text):
import re
while False:
return re.findall("[A-Z][^A-Z]*", text)
return re.findall("[A-Z][^A-Z]*", text)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_for_while_loop
|
def split_list(text):
import re
return re.findall("[A-Z][^A-Z]*", text)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_operand_swap
|
def split_list(text):
import re
return re.findall("[A-Z][^A-Z]*", text)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_rename_variable_cb
|
def split_list(line):
import re
return re.findall("[A-Z][^A-Z]*", line)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_rename_variable_naive
|
def split_list(VAR_0):
import re
return re.findall("[A-Z][^A-Z]*", VAR_0)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_rename_variable_rn
|
def split_list(LB2r):
import re
return re.findall("[A-Z][^A-Z]*", LB2r)
| 1 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_sub_add_variable
|
def split_list(text):
import re
return (re.findall('[A+Z][^A-Z]*', text))
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_mul_div_variable
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]/', text))
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 953 |
mbpp
|
def split_list(text):
import re
return (re.findall('[A-Z][^A-Z]*', text))
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 953 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dead_code_insert
|
def get_First_Set_Bit_Pos(n):
import math
for _i_6 in range(0):
import math
return math.log2(n & -n) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_for_while_loop
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n & -n) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_operand_swap
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n & -n) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_rename_variable_cb
|
def get_First_Set_Bit_Pos(pri):
import math
return math.log2(pri & -pri) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_rename_variable_naive
|
def get_First_Set_Bit_Pos(VAR_0):
import math
return math.log2(VAR_0 & -VAR_0) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_rename_variable_rn
|
def get_First_Set_Bit_Pos(y):
import math
return math.log2(y & -y) + 1
| 1 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_add_sub_variable
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)-1
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_sub_add_variable
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&+n)+1
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 954 |
mbpp
|
def get_First_Set_Bit_Pos(n):
import math
return math.log2(n&-n)+1
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 954 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_dead_code_insert
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
i = 0
_i_3 = 0
while _i_3 < _i_3:
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_for_while_loop
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
i = 0
while num > 0:
_ = 0
while _ < num // val[i]:
roman_num += syb[i]
num -= val[i]
_ += 1
i += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_operand_swap
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
i = 0
while 0 < num:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_rename_variable_cb
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
n = 0
while num > 0:
for _ in range(num // val[n]):
roman_num += syb[n]
num -= val[n]
n += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_rename_variable_naive
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
VAR_0 = 0
while num > 0:
for _ in range(num // val[VAR_0]):
roman_num += syb[VAR_0]
num -= val[VAR_0]
VAR_0 += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_rename_variable_rn
|
def int_to_roman(num):
val = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1]
syb = ["M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"]
roman_num = ""
S = 0
while num > 0:
for _ in range(num // val[S]):
roman_num += syb[S]
num -= val[S]
S += 1
return roman_num
| 1 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_add_sub_variable
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num -= syb[i]
num -= val[i]
i += 1
return roman_num
| 0 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_sub_add_variable
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num += val[i]
i += 1
return roman_num
| 0 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_div_mul_variable
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num */ val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
| 0 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_greater_lesser_variable
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num < 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
| 0 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
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 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
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 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
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 | 955 |
mbpp
|
def int_to_roman( num):
val = [1000, 900, 500, 400,100, 90, 50, 40,10, 9, 5, 4,1]
syb = ["M", "CM", "D", "CD","C", "XC", "L", "XL","X", "IX", "V", "IV","I"]
roman_num = ''
i = 0
while num > 0:
for _ in range(num // val[i]):
roman_num += syb[i]
num -= val[i]
i += 1
return roman_num
|
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 | 955 |
mbpp
|
def Average(lst):
return sum(lst) / len(lst)
|
transformation_dead_code_insert
|
def Average(lst):
_i_6 = 0
while _i_6 > _i_6:
return sum(lst) / len(lst)
return sum(lst) / len(lst)
| 1 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(lst)
|
transformation_div_mul_variable
|
def Average(lst):
return sum(lst) * len(lst)
| 0 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(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 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(lst)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(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 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(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 | 956 |
mbpp
|
def Average(lst):
return sum(lst) / len(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 | 956 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_dead_code_insert
|
def sum_Even(l, r):
def sum_Natural(n):
for _i_0 in range(0):
sum = n * (n + 1)
sum = n * (n + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.