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_subarray_product(arr):
n = len(arr)
max_ending_here = 1
min_ending_here = 1
max_so_far = 0
flag = 0
for i in range(0, n):
if arr[i] > 0:
max_ending_here = max_ending_here * arr[i]
min_ending_here = min (min_ending_here * arr[i], 1)
flag = 1
elif arr[i] == 0:
max_ending_here = 1
min_ending_here = 1
else:
temp = max_ending_here
max_ending_here = max (min_ending_here * arr[i], 1)
min_ending_here = temp * arr[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if flag == 0 and max_so_far == 0:
return 0
return max_so_far
|
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 | 460 |
mbpp
|
def max_subarray_product(arr):
n = len(arr)
max_ending_here = 1
min_ending_here = 1
max_so_far = 0
flag = 0
for i in range(0, n):
if arr[i] > 0:
max_ending_here = max_ending_here * arr[i]
min_ending_here = min (min_ending_here * arr[i], 1)
flag = 1
elif arr[i] == 0:
max_ending_here = 1
min_ending_here = 1
else:
temp = max_ending_here
max_ending_here = max (min_ending_here * arr[i], 1)
min_ending_here = temp * arr[i]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if flag == 0 and max_so_far == 0:
return 0
return max_so_far
|
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 | 460 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_dead_code_insert
|
def check_value(dict, n):
_i_6 = 0
if _i_6 < _i_6:
return result
result = all(x == n for x in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_for_while_loop
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_operand_swap
|
def check_value(dict, n):
result = all(n == x for x in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_rename_variable_cb
|
def check_value(dict, n):
result = all(v == n for v in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_rename_variable_naive
|
def check_value(dict, n):
result = all(VAR_0 == n for VAR_0 in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_rename_variable_rn
|
def check_value(dict, P):
result = all(x == P for x in dict.values())
return result
| 1 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
return result
|
transformation_equalto_exclamation_variable
|
def check_value(dict, n):
result = all(x != n for x in dict.values())
return result
| 0 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
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 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
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 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
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 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
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 | 461 |
mbpp
|
def check_value(dict, n):
result = all(x == n for x in dict.values())
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 | 461 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dead_code_insert
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
while False:
return find_peak_util(arr, 0, n - 1, n)
mid = low + (high - low) / 2
mid = int(mid)
if (mid == 0 or arr[mid - 1] <= arr[mid]) and (
mid == n - 1 or arr[mid + 1] <= arr[mid]
):
return mid
elif mid > 0 and arr[mid - 1] > arr[mid]:
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_for_while_loop
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low) / 2
mid = int(mid)
if (mid == 0 or arr[mid - 1] <= arr[mid]) and (
mid == n - 1 or arr[mid + 1] <= arr[mid]
):
return mid
elif mid > 0 and arr[mid - 1] > arr[mid]:
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_operand_swap
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low) / 2
mid = int(mid)
if (mid == 0 or arr[mid - 1] <= arr[mid]) and (
mid == n - 1 or arr[mid + 1] <= arr[mid]
):
return mid
elif 0 < mid and arr[mid - 1] > arr[mid]:
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_rename_variable_cb
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
n2 = low + (high - low) / 2
n2 = int(n2)
if (n2 == 0 or arr[n2 - 1] <= arr[n2]) and (
n2 == n - 1 or arr[n2 + 1] <= arr[n2]
):
return n2
elif n2 > 0 and arr[n2 - 1] > arr[n2]:
return find_peak_util(arr, low, (n2 - 1), n)
else:
return find_peak_util(arr, (n2 + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_rename_variable_naive
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
VAR_0 = low + (high - low) / 2
VAR_0 = int(VAR_0)
if (VAR_0 == 0 or arr[VAR_0 - 1] <= arr[VAR_0]) and (
VAR_0 == n - 1 or arr[VAR_0 + 1] <= arr[VAR_0]
):
return VAR_0
elif VAR_0 > 0 and arr[VAR_0 - 1] > arr[VAR_0]:
return find_peak_util(arr, low, (VAR_0 - 1), n)
else:
return find_peak_util(arr, (VAR_0 + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_rename_variable_rn
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
LVW = low + (high - low) / 2
LVW = int(LVW)
if (LVW == 0 or arr[LVW - 1] <= arr[LVW]) and (
LVW == n - 1 or arr[LVW + 1] <= arr[LVW]
):
return LVW
elif LVW > 0 and arr[LVW - 1] > arr[LVW]:
return find_peak_util(arr, low, (LVW - 1), n)
else:
return find_peak_util(arr, (LVW + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 1 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_add_sub_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low - (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_sub_add_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high + low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_div_mul_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)*2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_lesser_greater_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] >= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_greater_lesser_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid < 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_equalto_exclamation_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid != 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_and_or_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) or
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_or_and_variable
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 and arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 463 |
mbpp
|
def find_peak(arr, n):
def find_peak_util(arr, low, high, n):
mid = low + (high - low)/2
mid = int(mid)
if ((mid == 0 or arr[mid - 1] <= arr[mid]) and
(mid == n - 1 or arr[mid + 1] <= arr[mid])):
return mid
elif (mid > 0 and arr[mid - 1] > arr[mid]):
return find_peak_util(arr, low, (mid - 1), n)
else:
return find_peak_util(arr, (mid + 1), high, n)
return find_peak_util(arr, 0, n - 1, n)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 463 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dead_code_insert
|
def max_profit(price, k):
_i_2 = 0
while _i_2 > _i_2:
final_profit = [[None for x in range(n)] for y in range(k + 1)]
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j - 1], max_so_far)
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_for_while_loop
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
i = 0
while i < k + 1:
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j - 1], max_so_far)
i += 1
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_operand_swap
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if 0 == i or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j - 1], max_so_far)
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_rename_variable_cb
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for m in range(n):
if i == 0 or m == 0:
final_profit[i][m] = 0
else:
max_so_far = 0
for x in range(m):
curr_price = price[m] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][m] = max(final_profit[i][m - 1], max_so_far)
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_rename_variable_naive
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for VAR_0 in range(n):
if i == 0 or VAR_0 == 0:
final_profit[i][VAR_0] = 0
else:
max_so_far = 0
for x in range(VAR_0):
curr_price = price[VAR_0] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][VAR_0] = max(final_profit[i][VAR_0 - 1], max_so_far)
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_rename_variable_rn
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for l in range(n):
if i == 0 or l == 0:
final_profit[i][l] = 0
else:
max_so_far = 0
for x in range(l):
curr_price = price[l] - price[x] + final_profit[i - 1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][l] = max(final_profit[i][l - 1], max_so_far)
return final_profit[k][n - 1]
| 1 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_add_sub_variable
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k - 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_sub_add_variable
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] + price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_lesser_greater_variable
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far > curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_equalto_exclamation_variable
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i != 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_or_and_variable
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 and j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 466 |
mbpp
|
def max_profit(price, k):
n = len(price)
final_profit = [[None for x in range(n)] for y in range(k + 1)]
for i in range(k + 1):
for j in range(n):
if i == 0 or j == 0:
final_profit[i][j] = 0
else:
max_so_far = 0
for x in range(j):
curr_price = price[j] - price[x] + final_profit[i-1][x]
if max_so_far < curr_price:
max_so_far = curr_price
final_profit[i][j] = max(final_profit[i][j-1], max_so_far)
return final_profit[k][n-1]
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 466 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+1))
|
transformation_add_sub_variable
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)-1))
| 0 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+1))
|
transformation_equalto_exclamation_variable
|
def check_Consecutive(l):
return sorted(l) != list(range(min(l),max(l)+1))
| 0 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+1))
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+1))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+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 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+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 | 469 |
mbpp
|
def check_Consecutive(l):
return sorted(l) == list(range(min(l),max(l)+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 | 469 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dead_code_insert
|
def tuple_intersection(test_list1, test_list2):
if False:
return res
res = set([tuple(sorted(ele)) for ele in test_list1]) & set(
[tuple(sorted(ele)) for ele in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_for_while_loop
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set(
[tuple(sorted(ele)) for ele in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_operand_swap
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set(
[tuple(sorted(ele)) for ele in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_rename_variable_cb
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(test)) for test in test_list1]) & set(
[tuple(sorted(test)) for test in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_rename_variable_naive
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(VAR_0)) for VAR_0 in test_list1]) & set(
[tuple(sorted(VAR_0)) for VAR_0 in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_rename_variable_rn
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(dk4)) for dk4 in test_list1]) & set(
[tuple(sorted(dk4)) for dk4 in test_list2]
)
return res
| 1 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 470 |
mbpp
|
def tuple_intersection(test_list1, test_list2):
res = set([tuple(sorted(ele)) for ele in test_list1]) & set([tuple(sorted(ele)) for ele in test_list2])
return (res)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 470 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_dead_code_insert
|
def replace_char(str1, ch, newch):
while False:
str2 = str1.replace(ch, newch)
str2 = str1.replace(ch, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_for_while_loop
|
def replace_char(str1, ch, newch):
str2 = str1.replace(ch, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_operand_swap
|
def replace_char(str1, ch, newch):
str2 = str1.replace(ch, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_rename_variable_cb
|
def replace_char(str1, line, newch):
str2 = str1.replace(line, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_rename_variable_naive
|
def replace_char(str1, VAR_0, newch):
str2 = str1.replace(VAR_0, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_rename_variable_rn
|
def replace_char(str1, iU, newch):
str2 = str1.replace(iU, newch)
return str2
| 1 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
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 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
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 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
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 | 471 |
mbpp
|
def replace_char(str1,ch,newch):
str2 = str1.replace(ch, newch)
return str2
|
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 | 471 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_dead_code_insert
|
def sort_counter(dict1):
from collections import Counter
while False:
x = Counter(dict1)
x = Counter(dict1)
sort_counter = x.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_for_while_loop
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter = x.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_operand_swap
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter = x.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_rename_variable_cb
|
def sort_counter(dict1):
from collections import Counter
Counter = Counter(dict1)
sort_counter = Counter.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_rename_variable_naive
|
def sort_counter(dict1):
from collections import Counter
VAR_0 = Counter(dict1)
sort_counter = VAR_0.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_rename_variable_rn
|
def sort_counter(dict1):
from collections import Counter
E = Counter(dict1)
sort_counter = E.most_common()
return sort_counter
| 1 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
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 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
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 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
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 | 472 |
mbpp
|
def sort_counter(dict1):
from collections import Counter
x = Counter(dict1)
sort_counter=x.most_common()
return sort_counter
|
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 | 472 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_dead_code_insert
|
def big_sum(nums):
for _i_8 in range(0):
return sum
sum = max(nums) + min(nums)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_for_while_loop
|
def big_sum(nums):
sum = max(nums) + min(nums)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_operand_swap
|
def big_sum(nums):
sum = max(nums) + min(nums)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_rename_variable_cb
|
def big_sum(sum2):
sum = max(sum2) + min(sum2)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_rename_variable_naive
|
def big_sum(VAR_0):
sum = max(VAR_0) + min(VAR_0)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_rename_variable_rn
|
def big_sum(cs3m):
sum = max(cs3m) + min(cs3m)
return sum
| 1 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_add_sub_variable
|
def big_sum(nums):
sum= max(nums)-min(nums)
return sum
| 0 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
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 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
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 | 473 |
mbpp
|
def big_sum(nums):
sum= max(nums)+min(nums)
return sum
|
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 | 473 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.