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 sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
transformation_rename_variable_rn
|
def sort_on_occurence(lst):
dct = {}
for i, c in lst:
dct.setdefault(i, []).append(c)
return [(i, *dict.fromkeys(c), len(c)) for i, c in dct.items()]
| 1 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
transformation_mul_div_variable
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, /dict.fromkeys(j), len(j))
for i, j in dct.items()])
| 0 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
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 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
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 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
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 | 240 |
mbpp
|
def sort_on_occurence(lst):
dct = {}
for i, j in lst:
dct.setdefault(i, []).append(j)
return ([(i, *dict.fromkeys(j), len(j))
for i, j in dct.items()])
|
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 | 240 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_dead_code_insert
|
def next_Perfect_Square(N):
_i_4 = 0
if _i_4 < _i_4:
import math
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_for_while_loop
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_operand_swap
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_rename_variable_cb
|
def next_Perfect_Square(N):
import math
N2 = math.floor(math.sqrt(N)) + 1
return N2 * N2
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_rename_variable_naive
|
def next_Perfect_Square(N):
import math
VAR_0 = math.floor(math.sqrt(N)) + 1
return VAR_0 * VAR_0
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_rename_variable_rn
|
def next_Perfect_Square(N):
import math
K3885 = math.floor(math.sqrt(N)) + 1
return K3885 * K3885
| 1 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_add_sub_variable
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) - 1
return nextN * nextN
| 0 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_mul_div_variable
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN / nextN
| 0 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
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 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
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 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
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 | 241 |
mbpp
|
def next_Perfect_Square(N):
import math
nextN = math.floor(math.sqrt(N)) + 1
return nextN * nextN
|
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 | 241 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_dead_code_insert
|
def max_sum(arr, n):
_i_1 = 0
while _i_1 > _i_1:
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_for_while_loop
|
def max_sum(arr, n):
MSIBS = arr[:]
i = 0
while i < n:
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
i += 1
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_operand_swap
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[j] < arr[i] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_rename_variable_cb
|
def max_sum(arr, n):
MSIBS = arr[:]
for i2 in range(n):
for j in range(0, i2):
if arr[i2] > arr[j] and MSIBS[i2] < MSIBS[j] + arr[i2]:
MSIBS[i2] = MSIBS[j] + arr[i2]
MSDBS = arr[:]
for i2 in range(1, n + 1):
for j in range(1, i2):
if arr[-i2] > arr[-j] and MSDBS[-i2] < MSDBS[-j] + arr[-i2]:
MSDBS[-i2] = MSDBS[-j] + arr[-i2]
max_sum = float("-Inf")
for i2, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i2 + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_rename_variable_naive
|
def max_sum(arr, n):
MSIBS = arr[:]
for VAR_0 in range(n):
for j in range(0, VAR_0):
if arr[VAR_0] > arr[j] and MSIBS[VAR_0] < MSIBS[j] + arr[VAR_0]:
MSIBS[VAR_0] = MSIBS[j] + arr[VAR_0]
MSDBS = arr[:]
for VAR_0 in range(1, n + 1):
for j in range(1, VAR_0):
if arr[-VAR_0] > arr[-j] and MSDBS[-VAR_0] < MSDBS[-j] + arr[-VAR_0]:
MSDBS[-VAR_0] = MSDBS[-j] + arr[-VAR_0]
max_sum = float("-Inf")
for VAR_0, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, VAR_0 + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_rename_variable_rn
|
def max_sum(arr, n):
MSIBS = arr[:]
for Q in range(n):
for j in range(0, Q):
if arr[Q] > arr[j] and MSIBS[Q] < MSIBS[j] + arr[Q]:
MSIBS[Q] = MSIBS[j] + arr[Q]
MSDBS = arr[:]
for Q in range(1, n + 1):
for j in range(1, Q):
if arr[-Q] > arr[-j] and MSDBS[-Q] < MSDBS[-j] + arr[-Q]:
MSDBS[-Q] = MSDBS[-j] + arr[-Q]
max_sum = float("-Inf")
for Q, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, Q + j - k)
return max_sum
| 1 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_add_sub_variable
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] - arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_sub_add_variable
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[+i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_lesser_greater_variable
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] > MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_greater_lesser_variable
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] < arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_and_or_variable
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] or MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_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 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_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 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_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 | 242 |
mbpp
|
def max_sum(arr, n):
MSIBS = arr[:]
for i in range(n):
for j in range(0, i):
if arr[i] > arr[j] and MSIBS[i] < MSIBS[j] + arr[i]:
MSIBS[i] = MSIBS[j] + arr[i]
MSDBS = arr[:]
for i in range(1, n + 1):
for j in range(1, i):
if arr[-i] > arr[-j] and MSDBS[-i] < MSDBS[-j] + arr[-i]:
MSDBS[-i] = MSDBS[-j] + arr[-i]
max_sum = float("-Inf")
for i, j, k in zip(MSIBS, MSDBS, arr):
max_sum = max(max_sum, i + j - k)
return max_sum
|
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 | 242 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_dead_code_insert
|
def babylonian_squareroot(number):
if number == 0:
return 0
g = number / 2.0
g2 = g + 1
if False:
return g
while g != g2:
n = number / g
g2 = g
g = (g + n) / 2
return g
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_for_while_loop
|
def babylonian_squareroot(number):
if number == 0:
return 0
g = number / 2.0
g2 = g + 1
while g != g2:
n = number / g
g2 = g
g = (g + n) / 2
return g
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_operand_swap
|
def babylonian_squareroot(number):
if 0 == number:
return 0
g = number / 2.0
g2 = g + 1
while g != g2:
n = number / g
g2 = g
g = (g + n) / 2
return g
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_rename_variable_cb
|
def babylonian_squareroot(number):
if number == 0:
return 0
n2 = number / 2.0
g2 = n2 + 1
while n2 != g2:
n = number / n2
g2 = n2
n2 = (n2 + n) / 2
return n2
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_rename_variable_naive
|
def babylonian_squareroot(number):
if number == 0:
return 0
VAR_0 = number / 2.0
g2 = VAR_0 + 1
while VAR_0 != g2:
n = number / VAR_0
g2 = VAR_0
VAR_0 = (VAR_0 + n) / 2
return VAR_0
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_rename_variable_rn
|
def babylonian_squareroot(number):
if number == 0:
return 0
w = number / 2.0
g2 = w + 1
while w != g2:
n = number / w
g2 = w
w = (w + n) / 2
return w
| 1 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_add_sub_variable
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g - 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
| 0 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_div_mul_variable
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number*2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
| 0 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_equalto_exclamation_variable
|
def babylonian_squareroot(number):
if(number != 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
| 0 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_exclamation_equalto_variable
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g == g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
| 0 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
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 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
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 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
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 | 243 |
mbpp
|
def babylonian_squareroot(number):
if(number == 0):
return 0;
g = number/2.0;
g2 = g + 1;
while(g != g2):
n = number/ g;
g2 = g;
g = (g + n)/2;
return g;
|
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 | 243 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_dead_code_insert
|
def harmonic_sum(n):
if n < 2:
_i_7 = 0
if _i_7 > _i_7:
return 1 / n + (harmonic_sum(n - 1))
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_for_while_loop
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_operand_swap
|
def harmonic_sum(n):
if 2 > n:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_rename_variable_cb
|
def harmonic_sum(i):
if i < 2:
return 1
else:
return 1 / i + (harmonic_sum(i - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_rename_variable_naive
|
def harmonic_sum(VAR_0):
if VAR_0 < 2:
return 1
else:
return 1 / VAR_0 + (harmonic_sum(VAR_0 - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_rename_variable_rn
|
def harmonic_sum(o):
if o < 2:
return 1
else:
return 1 / o + (harmonic_sum(o - 1))
| 1 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_add_sub_variable
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n - (harmonic_sum(n - 1))
| 0 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_sub_add_variable
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n + 1))
| 0 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_div_mul_variable
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 * n + (harmonic_sum(n - 1))
| 0 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
|
transformation_lesser_greater_variable
|
def harmonic_sum(n):
if n > 2:
return 1
else:
return 1 / n + (harmonic_sum(n - 1))
| 0 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(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 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(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 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(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 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(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 | 245 |
mbpp
|
def harmonic_sum(n):
if n < 2:
return 1
else:
return 1 / n + (harmonic_sum(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 | 245 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_dead_code_insert
|
def intersection_array(array_nums1, array_nums2):
for _i_0 in range(0):
return result
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_for_while_loop
|
def intersection_array(array_nums1, array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_operand_swap
|
def intersection_array(array_nums1, array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_rename_variable_cb
|
def intersection_array(array_nums1, result2):
result = list(filter(lambda x: x in array_nums1, result2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_rename_variable_naive
|
def intersection_array(array_nums1, array_nums2):
result = list(filter(lambda VAR_0: VAR_0 in array_nums1, array_nums2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
return result
|
transformation_rename_variable_rn
|
def intersection_array(R67408ej4J9, array_nums2):
result = list(filter(lambda x: x in R67408ej4J9, array_nums2))
return result
| 1 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
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 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
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 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
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 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
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 | 246 |
mbpp
|
def intersection_array(array_nums1,array_nums2):
result = list(filter(lambda x: x in array_nums1, array_nums2))
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 | 246 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dead_code_insert
|
def convert(numbers):
import cmath
for _i_8 in range(0):
return num
num = cmath.polar(numbers)
return num
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_for_while_loop
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return num
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_operand_swap
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return num
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_rename_variable_cb
|
def convert(x):
import cmath
num = cmath.polar(x)
return num
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_rename_variable_naive
|
def convert(VAR_0):
import cmath
num = cmath.polar(VAR_0)
return num
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_rename_variable_rn
|
def convert(numbers):
import cmath
J8b = cmath.polar(numbers)
return J8b
| 1 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 249 |
mbpp
|
def convert(numbers):
import cmath
num = cmath.polar(numbers)
return (num)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 249 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_dead_code_insert
|
def words_ae(text):
import re
_i_5 = 0
if _i_5 < _i_5:
list = re.findall("[ae]w+", text)
list = re.findall("[ae]w+", text)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_for_while_loop
|
def words_ae(text):
import re
list = re.findall("[ae]w+", text)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_operand_swap
|
def words_ae(text):
import re
list = re.findall("[ae]w+", text)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_rename_variable_cb
|
def words_ae(line):
import re
list = re.findall("[ae]w+", line)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_rename_variable_naive
|
def words_ae(VAR_0):
import re
list = re.findall("[ae]w+", VAR_0)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_rename_variable_rn
|
def words_ae(V771):
import re
list = re.findall("[ae]w+", V771)
return list
| 1 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_add_sub_variable
|
def words_ae(text):
import re
list = re.findall("[ae]\w-", text)
return list
| 0 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
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 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
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 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
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 | 251 |
mbpp
|
def words_ae(text):
import re
list = re.findall("[ae]\w+", text)
return list
|
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 | 251 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.