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 ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
transformation_rename_variable_naive
|
def ascii_value_string(VAR_0):
for i in range(len(VAR_0)):
return ord(VAR_0[i])
| 1 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
transformation_rename_variable_rn
|
def ascii_value_string(ZQ30):
for i in range(len(ZQ30)):
return ord(ZQ30[i])
| 1 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
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 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
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 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
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 | 143 |
mbpp
|
def ascii_value_string(str1):
for i in range(len(str1)):
return ord(str1[i])
|
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 | 143 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_dead_code_insert
|
def longest_subseq_with_diff_one(arr, n):
if False:
return result
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if (arr[i] == arr[j] + 1) or (arr[i] == arr[j] - 1):
dp[i] = max(dp[i], dp[j] + 1)
result = 1
for i in range(n):
if result < dp[i]:
result = dp[i]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_for_while_loop
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
i = 0
while i < n:
for j in range(i):
if (arr[i] == arr[j] + 1) or (arr[i] == arr[j] - 1):
dp[i] = max(dp[i], dp[j] + 1)
i += 1
result = 1
for i in range(n):
if result < dp[i]:
result = dp[i]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_operand_swap
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if (arr[i] == arr[j] + 1) or (arr[i] == arr[j] - 1):
dp[i] = max(dp[i], dp[j] + 1)
result = 1
for i in range(n):
if dp[i] > result:
result = dp[i]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_rename_variable_cb
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i2 in range(n)]
for i2 in range(n):
for j in range(i2):
if (arr[i2] == arr[j] + 1) or (arr[i2] == arr[j] - 1):
dp[i2] = max(dp[i2], dp[j] + 1)
result = 1
for i2 in range(n):
if result < dp[i2]:
result = dp[i2]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_rename_variable_naive
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for VAR_0 in range(n)]
for VAR_0 in range(n):
for j in range(VAR_0):
if (arr[VAR_0] == arr[j] + 1) or (arr[VAR_0] == arr[j] - 1):
dp[VAR_0] = max(dp[VAR_0], dp[j] + 1)
result = 1
for VAR_0 in range(n):
if result < dp[VAR_0]:
result = dp[VAR_0]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_rename_variable_rn
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for d in range(n)]
for d in range(n):
for j in range(d):
if (arr[d] == arr[j] + 1) or (arr[d] == arr[j] - 1):
dp[d] = max(dp[d], dp[j] + 1)
result = 1
for d in range(n):
if result < dp[d]:
result = dp[d]
return result
| 1 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_add_sub_variable
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]-1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
| 0 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_sub_add_variable
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]+1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
| 0 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_lesser_greater_variable
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result > dp[i]):
result = dp[i]
return result
| 0 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_equalto_exclamation_variable
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] != arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
| 0 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
|
transformation_or_and_variable
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) and (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
return result
| 0 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
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 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
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 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
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 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
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 | 146 |
mbpp
|
def longest_subseq_with_diff_one(arr, n):
dp = [1 for i in range(n)]
for i in range(n):
for j in range(i):
if ((arr[i] == arr[j]+1) or (arr[i] == arr[j]-1)):
dp[i] = max(dp[i], dp[j]+1)
result = 1
for i in range(n):
if (result < dp[i]):
result = dp[i]
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 | 146 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_dead_code_insert
|
def does_Contain_B(a, b, c):
if a == b:
return True
_i_0 = 0
while _i_0 < _i_0:
return True
if (b - a) * c > 0 and (b - a) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_for_while_loop
|
def does_Contain_B(a, b, c):
if a == b:
return True
if (b - a) * c > 0 and (b - a) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_operand_swap
|
def does_Contain_B(a, b, c):
if b == a:
return True
if (b - a) * c > 0 and (b - a) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_rename_variable_cb
|
def does_Contain_B(a2, b, c):
if a2 == b:
return True
if (b - a2) * c > 0 and (b - a2) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_rename_variable_naive
|
def does_Contain_B(VAR_0, b, c):
if VAR_0 == b:
return True
if (b - VAR_0) * c > 0 and (b - VAR_0) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_rename_variable_rn
|
def does_Contain_B(a, n, c):
if a == n:
return True
if (n - a) * c > 0 and (n - a) % c == 0:
return True
return False
| 1 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_sub_add_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b + a) * c > 0 and (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_mul_div_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) / c > 0 and (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_greater_lesser_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c < 0 and (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_equalto_exclamation_variable
|
def does_Contain_B(a,b,c):
if (a != b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_true_false_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return False
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_false_true_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return True
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
return False
|
transformation_and_or_variable
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 or (b - a) % c == 0):
return True
return False
| 0 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
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 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
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 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
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 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
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 | 147 |
mbpp
|
def does_Contain_B(a,b,c):
if (a == b):
return True
if ((b - a) * c > 0 and (b - a) % c == 0):
return True
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 | 147 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_dead_code_insert
|
def merge_sort(x):
def merge(a, b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
_i_7 = 0
if _i_7 < _i_7:
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a, b)
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_for_while_loop
|
def merge_sort(x):
def merge(a, b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_operand_swap
|
def merge_sort(x):
def merge(a, b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if 0 == len(x) or len(x) == 1:
return x
else:
middle = len(x) // 2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_rename_variable_cb
|
def merge_sort(x):
def merge(a2, b):
c = []
while len(a2) != 0 and len(b) != 0:
if a2[0] < b[0]:
c.append(a2[0])
a2.remove(a2[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a2) == 0:
c += b
else:
c += a2
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
a2 = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a2, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_rename_variable_naive
|
def merge_sort(x):
def merge(VAR_0, b):
c = []
while len(VAR_0) != 0 and len(b) != 0:
if VAR_0[0] < b[0]:
c.append(VAR_0[0])
VAR_0.remove(VAR_0[0])
else:
c.append(b[0])
b.remove(b[0])
if len(VAR_0) == 0:
c += b
else:
c += VAR_0
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
VAR_0 = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(VAR_0, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_rename_variable_rn
|
def merge_sort(x):
def merge(G, b):
c = []
while len(G) != 0 and len(b) != 0:
if G[0] < b[0]:
c.append(G[0])
G.remove(G[0])
else:
c.append(b[0])
b.remove(b[0])
if len(G) == 0:
c += b
else:
c += G
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x) // 2
G = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(G, b)
| 1 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_add_sub_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c -= b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_div_mul_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)*/2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_lesser_greater_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] > b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_equalto_exclamation_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) != 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_exclamation_equalto_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) == 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_and_or_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 or len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_or_and_variable
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 and len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
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 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
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 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
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 | 149 |
mbpp
|
def merge_sort(x):
def merge(a,b):
c = []
while len(a) != 0 and len(b) != 0:
if a[0] < b[0]:
c.append(a[0])
a.remove(a[0])
else:
c.append(b[0])
b.remove(b[0])
if len(a) == 0:
c += b
else:
c += a
return c
if len(x) == 0 or len(x) == 1:
return x
else:
middle = len(x)//2
a = merge_sort(x[:middle])
b = merge_sort(x[middle:])
return merge(a,b)
|
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 | 149 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
transformation_dead_code_insert
|
def parabola_vertex(a, b, c):
for _i_9 in range(0):
return vertex
vertex = ((-b / (2 * a)), (((4 * a * c) - (b * b)) / (4 * a)))
return vertex
| 1 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
transformation_sub_add_variable
|
def parabola_vertex(a, b, c):
vertex=(((+b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
| 0 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
transformation_mul_div_variable
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 / a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
| 0 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
transformation_div_mul_variable
|
def parabola_vertex(a, b, c):
vertex=(((-b * (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
| 0 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
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 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
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 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
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 | 150 |
mbpp
|
def parabola_vertex(a, b, c):
vertex=(((-b / (2 * a)),(((4 * a * c) - (b * b)) / (4 * a))))
return vertex
|
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 | 150 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_dead_code_insert
|
def specified_element(nums, N):
if False:
result = [i[N] for i in nums]
result = [i[N] for i in nums]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_for_while_loop
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_operand_swap
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_rename_variable_cb
|
def specified_element(nums, N):
result = [pr[N] for pr in nums]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_rename_variable_naive
|
def specified_element(VAR_0, N):
result = [i[N] for i in VAR_0]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in nums]
return result
|
transformation_rename_variable_rn
|
def specified_element(nums, N):
result = [i2[N] for i2 in nums]
return result
| 1 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in 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 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in 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 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in 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 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in 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 | 151 |
mbpp
|
def specified_element(nums, N):
result = [i[N] for i in 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 | 151 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_dead_code_insert
|
def even_bit_toggle_number(n):
while False:
res = 0
res = 0
count = 0
temp = n
while temp > 0:
if count % 2 == 1:
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_for_while_loop
|
def even_bit_toggle_number(n):
res = 0
count = 0
temp = n
while temp > 0:
if count % 2 == 1:
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_operand_swap
|
def even_bit_toggle_number(n):
res = 0
count = 0
temp = n
while 0 < temp:
if count % 2 == 1:
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_rename_variable_cb
|
def even_bit_toggle_number(n):
res = 0
temp2 = 0
temp = n
while temp > 0:
if temp2 % 2 == 1:
res = res | (1 << temp2)
temp2 = temp2 + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_rename_variable_naive
|
def even_bit_toggle_number(n):
res = 0
VAR_0 = 0
temp = n
while temp > 0:
if VAR_0 % 2 == 1:
res = res | (1 << VAR_0)
VAR_0 = VAR_0 + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_rename_variable_rn
|
def even_bit_toggle_number(n):
res = 0
N2hQs = 0
temp = n
while temp > 0:
if N2hQs % 2 == 1:
res = res | (1 << N2hQs)
N2hQs = N2hQs + 1
temp >>= 1
return n ^ res
| 1 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_add_sub_variable
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count - 1
temp >>= 1
return n ^ res
| 0 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_lesser_greater_variable
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 >< count)
count = count + 1
temp >>= 1
return n ^ res
| 0 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_greater_lesser_variable
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp < 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
| 0 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_equalto_exclamation_variable
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 != 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
| 0 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ 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 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ res
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ 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 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ 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 | 152 |
mbpp
|
def even_bit_toggle_number(n) :
res = 0; count = 0; temp = n
while (temp > 0) :
if (count % 2 == 1) :
res = res | (1 << count)
count = count + 1
temp >>= 1
return n ^ 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 | 152 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_dead_code_insert
|
def tuple_int_str(tuple_str):
_i_8 = 0
while _i_8 < _i_8:
return result
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
| 1 | 153 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_for_while_loop
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
| 1 | 153 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_operand_swap
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
| 1 | 153 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_rename_variable_cb
|
def tuple_int_str(tuple_str):
result = tuple((int(i[0]), int(i[1])) for i in tuple_str)
return result
| 1 | 153 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_rename_variable_naive
|
def tuple_int_str(tuple_str):
result = tuple((int(VAR_0[0]), int(VAR_0[1])) for VAR_0 in tuple_str)
return result
| 1 | 153 |
mbpp
|
def tuple_int_str(tuple_str):
result = tuple((int(x[0]), int(x[1])) for x in tuple_str)
return result
|
transformation_rename_variable_rn
|
def tuple_int_str(tuple_str):
result = tuple((int(E[0]), int(E[1])) for E in tuple_str)
return result
| 1 | 153 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.