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 sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_for_while_loop
|
def sum_Even(l, r):
def sum_Natural(n):
sum = n * (n + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_operand_swap
|
def sum_Even(l, r):
def sum_Natural(n):
sum = n * (n + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_rename_variable_cb
|
def sum_Even(l, r):
def sum_Natural(i):
sum = i * (i + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_rename_variable_naive
|
def sum_Even(l, r):
def sum_Natural(VAR_0):
sum = VAR_0 * (VAR_0 + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_rename_variable_rn
|
def sum_Even(l, r):
def sum_Natural(n2):
sum = n2 * (n2 + 1)
return int(sum)
return sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2))
| 1 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_add_sub_variable
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n - 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
| 0 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_sub_add_variable
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) + sum_Natural(int((l - 1) / 2)))
| 0 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_mul_div_variable
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n / (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
| 0 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_div_mul_variable
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r * 2)) - sum_Natural(int((l - 1) / 2)))
| 0 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
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 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
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 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
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 | 959 |
mbpp
|
def sum_Even(l,r):
def sum_Natural(n):
sum = (n * (n + 1))
return int(sum)
return (sum_Natural(int(r / 2)) - sum_Natural(int((l - 1) / 2)))
|
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 | 959 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_dead_code_insert
|
def check(string):
if len(set(string).intersection("AEIOUaeiou")) >= 5:
while False:
return "not accepted"
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_for_while_loop
|
def check(string):
if len(set(string).intersection("AEIOUaeiou")) >= 5:
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_operand_swap
|
def check(string):
if 5 <= len(set(string).intersection("AEIOUaeiou")):
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_rename_variable_cb
|
def check(line):
if len(set(line).intersection("AEIOUaeiou")) >= 5:
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_rename_variable_naive
|
def check(VAR_0):
if len(set(VAR_0).intersection("AEIOUaeiou")) >= 5:
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_rename_variable_rn
|
def check(Vm201B):
if len(set(Vm201B).intersection("AEIOUaeiou")) >= 5:
return "accepted"
else:
return "not accepted"
| 1 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_greater_lesser_variable
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))<=5:
return ('accepted')
else:
return ("not accepted")
| 0 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
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 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
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 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
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 | 964 |
mbpp
|
def check(string):
if len(set(string).intersection("AEIOUaeiou"))>=5:
return ('accepted')
else:
return ("not accepted")
|
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 | 964 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dead_code_insert
|
def floor_Max(A, B, N):
for _i_1 in range(0):
x = min(B - 1, N)
x = min(B - 1, N)
return (A * x) // B
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_for_while_loop
|
def floor_Max(A, B, N):
x = min(B - 1, N)
return (A * x) // B
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_operand_swap
|
def floor_Max(A, B, N):
x = min(B - 1, N)
return (A * x) // B
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_rename_variable_cb
|
def floor_Max(A, x2, N):
x = min(x2 - 1, N)
return (A * x) // x2
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_rename_variable_naive
|
def floor_Max(A, VAR_0, N):
x = min(VAR_0 - 1, N)
return (A * x) // VAR_0
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_rename_variable_rn
|
def floor_Max(A, Q, N):
x = min(Q - 1, N)
return (A * x) // Q
| 1 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_sub_add_variable
|
def floor_Max(A,B,N):
x = min(B + 1,N)
return (A*x) // B
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_mul_div_variable
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A/x) // B
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_div_mul_variable
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) */ B
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 965 |
mbpp
|
def floor_Max(A,B,N):
x = min(B - 1,N)
return (A*x) // B
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 965 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_dead_code_insert
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n):
if dp[i] != -1:
if i + a <= n:
while False:
if i + c <= n:
dp[i + c] = max(dp[i] + 1, dp[i + c])
dp[i + a] = max(
dp[i] + 1,
dp[i + a],
)
if i + b <= n:
dp[i + b] = max(dp[i] + 1, dp[i + b])
if i + c <= n:
dp[i + c] = max(dp[i] + 1, dp[i + c])
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_for_while_loop
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
i = 0
while i < n:
if dp[i] != -1:
if i + a <= n:
dp[i + a] = max(
dp[i] + 1,
dp[i + a],
)
if i + b <= n:
dp[i + b] = max(dp[i] + 1, dp[i + b])
if i + c <= n:
dp[i + c] = max(dp[i] + 1, dp[i + c])
i += 1
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_operand_swap
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n):
if -1 != dp[i]:
if i + a <= n:
dp[i + a] = max(
dp[i] + 1,
dp[i + a],
)
if i + b <= n:
dp[i + b] = max(dp[i] + 1, dp[i + b])
if i + c <= n:
dp[i + c] = max(dp[i] + 1, dp[i + c])
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_rename_variable_cb
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
for a2 in range(0, n):
if dp[a2] != -1:
if a2 + a <= n:
dp[a2 + a] = max(
dp[a2] + 1,
dp[a2 + a],
)
if a2 + b <= n:
dp[a2 + b] = max(dp[a2] + 1, dp[a2 + b])
if a2 + c <= n:
dp[a2 + c] = max(dp[a2] + 1, dp[a2 + c])
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_rename_variable_naive
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
for VAR_0 in range(0, n):
if dp[VAR_0] != -1:
if VAR_0 + a <= n:
dp[VAR_0 + a] = max(
dp[VAR_0] + 1,
dp[VAR_0 + a],
)
if VAR_0 + b <= n:
dp[VAR_0 + b] = max(dp[VAR_0] + 1, dp[VAR_0 + b])
if VAR_0 + c <= n:
dp[VAR_0 + c] = max(dp[VAR_0] + 1, dp[VAR_0 + c])
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_rename_variable_rn
|
def maximum_segments(n, a, b, c):
dp = [-1] * (n + 10)
dp[0] = 0
for D in range(0, n):
if dp[D] != -1:
if D + a <= n:
dp[D + a] = max(
dp[D] + 1,
dp[D + a],
)
if D + b <= n:
dp[D + b] = max(dp[D] + 1, dp[D + b])
if D + c <= n:
dp[D + c] = max(dp[D] + 1, dp[D + c])
return dp[n]
| 1 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_add_sub_variable
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n - 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_sub_add_variable
|
def maximum_segments(n, a, b, c) :
dp = [+1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_mul_div_variable
|
def maximum_segments(n, a, b, c) :
dp = [-1] / (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_lesser_greater_variable
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a >= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_exclamation_equalto_variable
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] == -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[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 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[n]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[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 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[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 | 968 |
mbpp
|
def maximum_segments(n, a, b, c) :
dp = [-1] * (n + 10)
dp[0] = 0
for i in range(0, n) :
if (dp[i] != -1) :
if(i + a <= n ):
dp[i + a] = max(dp[i] + 1,
dp[i + a])
if(i + b <= n ):
dp[i + b] = max(dp[i] + 1,
dp[i + b])
if(i + c <= n ):
dp[i + c] = max(dp[i] + 1,
dp[i + c])
return dp[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 | 968 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_dead_code_insert
|
def min_sum_path(A):
memo = [None] * len(A)
_i_3 = 0
if _i_3 < _i_3:
memo[j] = A[i][j] + min(memo[j], memo[j + 1])
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1, -1):
for j in range(len(A[i])):
memo[j] = A[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_for_while_loop
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
i = 0
while i < len(A[n]):
memo[i] = A[n][i]
i += 1
for i in range(len(A) - 2, -1, -1):
for j in range(len(A[i])):
memo[j] = A[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_operand_swap
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1, -1):
for j in range(len(A[i])):
memo[j] = A[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_rename_variable_cb
|
def min_sum_path(l):
memo = [None] * len(l)
n = len(l) - 1
for i in range(len(l[n])):
memo[i] = l[n][i]
for i in range(len(l) - 2, -1, -1):
for j in range(len(l[i])):
memo[j] = l[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_rename_variable_naive
|
def min_sum_path(VAR_0):
memo = [None] * len(VAR_0)
n = len(VAR_0) - 1
for i in range(len(VAR_0[n])):
memo[i] = VAR_0[n][i]
for i in range(len(VAR_0) - 2, -1, -1):
for j in range(len(VAR_0[i])):
memo[j] = VAR_0[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_rename_variable_rn
|
def min_sum_path(K):
memo = [None] * len(K)
n = len(K) - 1
for i in range(len(K[n])):
memo[i] = K[n][i]
for i in range(len(K) - 2, -1, -1):
for j in range(len(K[i])):
memo[j] = K[i][j] + min(memo[j], memo[j + 1])
return memo[0]
| 1 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_add_sub_variable
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] - min(memo[j],
memo[j + 1])
return memo[0]
| 0 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_sub_add_variable
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) + 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
| 0 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_mul_div_variable
|
def min_sum_path(A):
memo = [None] / len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
| 0 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
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 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
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 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
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 | 971 |
mbpp
|
def min_sum_path(A):
memo = [None] * len(A)
n = len(A) - 1
for i in range(len(A[n])):
memo[i] = A[n][i]
for i in range(len(A) - 2, -1,-1):
for j in range( len(A[i])):
memo[j] = A[i][j] + min(memo[j],
memo[j + 1])
return memo[0]
|
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 | 971 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dead_code_insert
|
if False:
from typing import List
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == "(":
current_depth += 1
current_string.append(c)
elif c == ")":
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append("".join(current_string))
current_string.clear()
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_for_while_loop
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
_c_i = 0
while _c_i < len(paren_string):
c = paren_string[_c_i]
if c == "(":
current_depth += 1
current_string.append(c)
elif c == ")":
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append("".join(current_string))
current_string.clear()
_c_i += 1
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_operand_swap
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if "(" == c:
current_depth += 1
current_string.append(c)
elif c == ")":
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append("".join(current_string))
current_string.clear()
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_rename_variable_cb
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
result2 = []
current_depth = 0
for c in paren_string:
if c == "(":
current_depth += 1
result2.append(c)
elif c == ")":
current_depth -= 1
result2.append(c)
if current_depth == 0:
result.append("".join(result2))
result2.clear()
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_rename_variable_naive
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for VAR_0 in paren_string:
if VAR_0 == "(":
current_depth += 1
current_string.append(VAR_0)
elif VAR_0 == ")":
current_depth -= 1
current_string.append(VAR_0)
if current_depth == 0:
result.append("".join(current_string))
current_string.clear()
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_rename_variable_rn
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
I2N427L32EDLbd = []
current_depth = 0
for c in paren_string:
if c == "(":
current_depth += 1
I2N427L32EDLbd.append(c)
elif c == ")":
current_depth -= 1
I2N427L32EDLbd.append(c)
if current_depth == 0:
result.append("".join(I2N427L32EDLbd))
I2N427L32EDLbd.clear()
return result
| 1 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_add_sub_variable
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth -= 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_sub_add_variable
|
from typing import List
def separate_paren_groups(paren_string: str) +> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_greater_lesser_variable
|
from typing import List
def separate_paren_groups(paren_string: str) -< List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_equalto_exclamation_variable
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c != '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dissimilar_code_injection_0
|
from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dissimilar_code_injection_1
|
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0.5
"""
return number % 1.0
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dissimilar_code_injection_2
|
from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dissimilar_code_injection_3
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 0 | 1 |
mbpp
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
|
transformation_dissimilar_code_injection_4
|
from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
| 0 | 1 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dead_code_insert
|
_i_4 = 0
if _i_4 < _i_4:
return sum(abs(x - mean) for x in numbers) / len(numbers)
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_for_while_loop
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_operand_swap
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_rename_variable_cb
|
from typing import List
def mean_absolute_deviation(x2: List[float]) -> float:
mean = sum(x2) / len(x2)
return sum(abs(x - mean) for x in x2) / len(x2)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_rename_variable_naive
|
from typing import List
def mean_absolute_deviation(VAR_0: List[float]) -> float:
mean = sum(VAR_0) / len(VAR_0)
return sum(abs(x - mean) for x in VAR_0) / len(VAR_0)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_rename_variable_rn
|
from typing import List
def mean_absolute_deviation(s71c53j: List[float]) -> float:
mean = sum(s71c53j) / len(s71c53j)
return sum(abs(x - mean) for x in s71c53j) / len(s71c53j)
| 1 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_sub_add_variable
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) +> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_div_mul_variable
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) * len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_greater_lesser_variable
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -< float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dissimilar_code_injection_0
|
from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dissimilar_code_injection_1
|
from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
result.append(''.join(current_string))
current_string.clear()
return result
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dissimilar_code_injection_2
|
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0.5
"""
return number % 1.0
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dissimilar_code_injection_3
|
from typing import List
def below_zero(operations: List[int]) -> bool:
balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
| 0 | 4 |
mbpp
|
from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
transformation_dissimilar_code_injection_4
|
from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
| 0 | 4 |
mbpp
|
from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
|
transformation_dead_code_insert
|
from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
sum_value = 0
prod_value = 1
if False:
prod_value *= n
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
| 1 | 8 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.