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_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_end... | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 833 | mbpp |
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_end... | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 833 | mbpp |
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_end... | 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 | 833 | mbpp |
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_end... | 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 | 833 | mbpp |
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_end... | 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 | 833 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_dead_code_insert | def sort_tuple(tup):
n = len(tup)
for i in range(n):
_i_7 = 0
if _i_7 > _i_7:
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
for j in range(n - i - 1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] ... | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_for_while_loop | def sort_tuple(tup):
n = len(tup)
i = 0
while i < n:
for j in range(n - i - 1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
i += 1
return tup | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_operand_swap | def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n - i - 1):
if tup[j + 1][0] < tup[j][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_rename_variable_cb | def sort_tuple(i2):
n = len(i2)
for i in range(n):
for j in range(n - i - 1):
if i2[j][0] > i2[j + 1][0]:
i2[j], i2[j + 1] = i2[j + 1], i2[j]
return i2 | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_rename_variable_naive | def sort_tuple(VAR_0):
n = len(VAR_0)
for i in range(n):
for j in range(n - i - 1):
if VAR_0[j][0] > VAR_0[j + 1][0]:
VAR_0[j], VAR_0[j + 1] = VAR_0[j + 1], VAR_0[j]
return VAR_0 | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_rename_variable_rn | def sort_tuple(Zm6):
n = len(Zm6)
for i in range(n):
for j in range(n - i - 1):
if Zm6[j][0] > Zm6[j + 1][0]:
Zm6[j], Zm6[j + 1] = Zm6[j + 1], Zm6[j]
return Zm6 | 1 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_add_sub_variable | def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j - 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 0 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_sub_add_variable | def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n+i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 0 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_greater_lesser_variable | def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] < tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 0 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 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 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 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 | 836 | mbpp |
def sort_tuple(tup):
n = len(tup)
for i in range(n):
for j in range(n-i-1):
if tup[j][0] > tup[j + 1][0]:
tup[j], tup[j + 1] = tup[j + 1], tup[j]
return tup | 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 | 836 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dead_code_insert | def get_inv_count(arr, n):
for _i_5 in range(0):
if arr[i] > arr[j]:
inv_count += 1
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if arr[i] > arr[j]:
inv_count += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_for_while_loop | def get_inv_count(arr, n):
inv_count = 0
i = 0
while i < n:
for j in range(i + 1, n):
if arr[i] > arr[j]:
inv_count += 1
i += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_operand_swap | def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if arr[j] < arr[i]:
inv_count += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_rename_variable_cb | def get_inv_count(arr, n):
inv_count = 0
for i2 in range(n):
for j in range(i2 + 1, n):
if arr[i2] > arr[j]:
inv_count += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_rename_variable_naive | def get_inv_count(arr, VAR_0):
inv_count = 0
for i in range(VAR_0):
for j in range(i + 1, VAR_0):
if arr[i] > arr[j]:
inv_count += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_rename_variable_rn | def get_inv_count(sHU, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if sHU[i] > sHU[j]:
inv_count += 1
return inv_count | 1 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_add_sub_variable | def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i - 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_greater_lesser_variable | def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] < arr[j]):
inv_count += 1
return inv_count | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dissimilar_code_injection_2 | def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dissimilar_code_injection_3 | def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums | 0 | 838 | mbpp |
def get_inv_count(arr, n):
inv_count = 0
for i in range(n):
for j in range(i + 1, n):
if (arr[i] > arr[j]):
inv_count += 1
return inv_count | transformation_dissimilar_code_injection_4 | def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n] | 0 | 838 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_dead_code_insert | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
while False:
if count % 2 != 0:
return arr[i]
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if count % 2 != 0:
r... | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_for_while_loop | def get_odd_occurence(arr, arr_size):
i = 0
while i < arr_size:
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if count % 2 != 0:
return arr[i]
i += 1
return -1 | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_operand_swap | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if 0 != count % 2:
return arr[i]
return -1 | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_rename_variable_cb | def get_odd_occurence(a, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if a[i] == a[j]:
count += 1
if count % 2 != 0:
return a[i]
return -1 | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_rename_variable_naive | def get_odd_occurence(VAR_0, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if VAR_0[i] == VAR_0[j]:
count += 1
if count % 2 != 0:
return VAR_0[i]
return -1 | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_rename_variable_rn | def get_odd_occurence(c19, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if c19[i] == c19[j]:
count += 1
if count % 2 != 0:
return c19[i]
return -1 | 1 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_add_sub_variable | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count -= 1
if (count % 2 != 0):
return arr[i]
return -1 | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_sub_add_variable | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return +1 | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_equalto_exclamation_variable | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] != arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_exclamation_equalto_variable | def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 == 0):
return arr[i]
return -1 | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -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-... | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -1 | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -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 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -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 | 839 | mbpp |
def get_odd_occurence(arr, arr_size):
for i in range(0, arr_size):
count = 0
for j in range(0, arr_size):
if arr[i] == arr[j]:
count += 1
if (count % 2 != 0):
return arr[i]
return -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 | 839 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_dead_code_insert | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
_i_7 = 0
while _i_7 > _i_7:
uglies.append(ugly)
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_for_while_loop | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
_ugly_i = 0
while _ugly_i < len(uglies):
ugly = uglies[_ugly_i]
yield ugly * prime
_ugly_i += 1
merged = heapq.merge(*map(gen, primes))
while len(uglies) < ... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_operand_swap | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while n > len(uglies):
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(u... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_rename_variable_cb | def nth_super_ugly_number(n, primes):
import heapq
merged2 = [1]
def gen(prime):
for ugly in merged2:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(merged2) < n:
ugly = next(merged)
if ugly != merged2[-1]:
merged2.app... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_rename_variable_naive | def nth_super_ugly_number(n, primes):
import heapq
VAR_0 = [1]
def gen(prime):
for ugly in VAR_0:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(VAR_0) < n:
ugly = next(merged)
if ugly != VAR_0[-1]:
VAR_0.append(ugly)
... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_rename_variable_rn | def nth_super_ugly_number(n, primes):
import heapq
dar5So = [1]
def gen(prime):
for ugly in dar5So:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(dar5So) < n:
ugly = next(merged)
if ugly != dar5So[-1]:
dar5So.append(u... | 1 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_sub_add_variable | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[+1]:
uglies.append(ugly)
... | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_mul_div_variable | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly / prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_lesser_greater_variable | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) > n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_exclamation_equalto_variable | def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly == uglies[-1]:
uglies.append(ugly)
... | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | 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 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | 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 | 840 | mbpp |
def nth_super_ugly_number(n, primes):
import heapq
uglies = [1]
def gen(prime):
for ugly in uglies:
yield ugly * prime
merged = heapq.merge(*map(gen, primes))
while len(uglies) < n:
ugly = next(merged)
if ugly != uglies[-1]:
uglies.append(ugly)
... | 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 | 840 | mbpp |
def lcopy(xs):
return xs[:] | transformation_dead_code_insert | def lcopy(xs):
for _i_3 in range(0):
return xs[:]
return xs[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_for_while_loop | def lcopy(xs):
return xs[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_operand_swap | def lcopy(xs):
return xs[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_rename_variable_cb | def lcopy(lines):
return lines[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_rename_variable_naive | def lcopy(VAR_0):
return VAR_0[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_rename_variable_rn | def lcopy(Wz):
return Wz[:] | 1 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 844 | mbpp |
def lcopy(xs):
return xs[:] | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 844 | mbpp |
def lcopy(xs):
return xs[:] | 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 | 844 | mbpp |
def lcopy(xs):
return xs[:] | 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 | 844 | mbpp |
def lcopy(xs):
return xs[:] | 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 | 844 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_dead_code_insert | def area_trapezium(base1, base2, height):
for _i_0 in range(0):
area = 0.5 * (base1 + base2) * height
area = 0.5 * (base1 + base2) * height
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_for_while_loop | def area_trapezium(base1, base2, height):
area = 0.5 * (base1 + base2) * height
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_operand_swap | def area_trapezium(base1, base2, height):
area = 0.5 * (base1 + base2) * height
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_rename_variable_cb | def area_trapezium(base1, width, height):
area = 0.5 * (base1 + width) * height
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_rename_variable_naive | def area_trapezium(base1, VAR_0, height):
area = 0.5 * (base1 + VAR_0) * height
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_rename_variable_rn | def area_trapezium(base1, base2, I5v39N):
area = 0.5 * (base1 + base2) * I5v39N
return area | 1 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_add_sub_variable | def area_trapezium(base1,base2,height):
area = 0.5 * (base1 - base2) * height
return area | 0 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_mul_div_variable | def area_trapezium(base1,base2,height):
area = 0.5 / (base1 + base2) * height
return area | 0 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | 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 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | 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 | 845 | mbpp |
def area_trapezium(base1,base2,height):
area = 0.5 * (base1 + base2) * height
return area | 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 | 845 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_dead_code_insert | def raw_heap(rawheap):
import heapq as hq
_i_1 = 0
while _i_1 < _i_1:
return rawheap
hq.heapify(rawheap)
return rawheap | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_for_while_loop | def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_operand_swap | def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_rename_variable_cb | def raw_heap(lines):
import heapq as hq
hq.heapify(lines)
return lines | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_rename_variable_naive | def raw_heap(VAR_0):
import heapq as hq
hq.heapify(VAR_0)
return VAR_0 | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_rename_variable_rn | def raw_heap(n1f8U2p):
import heapq as hq
hq.heapify(n1f8U2p)
return n1f8U2p | 1 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-... | 0 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | 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 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | 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 | 851 | mbpp |
def raw_heap(rawheap):
import heapq as hq
hq.heapify(rawheap)
return rawheap | 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 | 851 | mbpp |
def check_Even_Parity(x):
parity = 0
while (x != 0):
x = x & (x - 1)
parity += 1
if (parity % 2 == 0):
return True
else:
return False | transformation_dead_code_insert | def check_Even_Parity(x):
for _i_4 in range(0):
return True
parity = 0
while x != 0:
x = x & (x - 1)
parity += 1
if parity % 2 == 0:
return True
else:
return False | 1 | 852 | mbpp |
def check_Even_Parity(x):
parity = 0
while (x != 0):
x = x & (x - 1)
parity += 1
if (parity % 2 == 0):
return True
else:
return False | transformation_for_while_loop | def check_Even_Parity(x):
parity = 0
while x != 0:
x = x & (x - 1)
parity += 1
if parity % 2 == 0:
return True
else:
return False | 1 | 852 | mbpp |
def check_Even_Parity(x):
parity = 0
while (x != 0):
x = x & (x - 1)
parity += 1
if (parity % 2 == 0):
return True
else:
return False | transformation_operand_swap | def check_Even_Parity(x):
parity = 0
while 0 != x:
x = x & (x - 1)
parity += 1
if parity % 2 == 0:
return True
else:
return False | 1 | 852 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.