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.