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 rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_rename_variable_cb
|
def rear_extract(test_list):
res = [r[-1] for r in test_list]
return res
| 1 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_rename_variable_naive
|
def rear_extract(test_list):
res = [VAR_0[-1] for VAR_0 in test_list]
return res
| 1 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_rename_variable_rn
|
def rear_extract(By302DK02):
res = [lis[-1] for lis in By302DK02]
return res
| 1 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_sub_add_variable
|
def rear_extract(test_list):
res = [lis[+1] for lis in test_list]
return (res)
| 0 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
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 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
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 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
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 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
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 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
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 | 269 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_dead_code_insert
|
def substract_elements(test_tup1, test_tup2):
while False:
return res
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_for_while_loop
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_operand_swap
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_cb
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i2, j: i2 - j, test_tup1, test_tup2))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_naive
|
def substract_elements(test_tup1, VAR_0):
res = tuple(map(lambda i, j: i - j, test_tup1, VAR_0))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_rn
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda I, j: I - j, test_tup1, test_tup2))
return res
| 1 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
return (res)
|
transformation_sub_add_variable
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i + j, test_tup1, test_tup2))
return (res)
| 0 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
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 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
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 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
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 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
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 | 270 |
mbpp
|
def substract_elements(test_tup1, test_tup2):
res = tuple(map(lambda i, j: i - j, test_tup1, test_tup2))
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 | 270 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_dead_code_insert
|
def even_binomial_Coeff_Sum(n):
if False:
return 1 << (n - 1)
import math
return 1 << (n - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_for_while_loop
|
def even_binomial_Coeff_Sum(n):
import math
return 1 << (n - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_operand_swap
|
def even_binomial_Coeff_Sum(n):
import math
return 1 << (n - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_rename_variable_cb
|
def even_binomial_Coeff_Sum(pri):
import math
return 1 << (pri - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_rename_variable_naive
|
def even_binomial_Coeff_Sum(VAR_0):
import math
return 1 << (VAR_0 - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_rename_variable_rn
|
def even_binomial_Coeff_Sum(d):
import math
return 1 << (d - 1)
| 1 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_sub_add_variable
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n + 1))
| 0 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (n - 1))
|
transformation_lesser_greater_variable
|
def even_binomial_Coeff_Sum( n):
import math
return (1 >< (n - 1))
| 0 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (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 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (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 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (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 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (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 | 271 |
mbpp
|
def even_binomial_Coeff_Sum( n):
import math
return (1 << (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 | 271 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_dead_code_insert
|
def volume_cylinder(r, h):
_i_0 = 0
if _i_0 < _i_0:
volume = 3.1415 * r * r * h
volume = 3.1415 * r * r * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_for_while_loop
|
def volume_cylinder(r, h):
volume = 3.1415 * r * r * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_operand_swap
|
def volume_cylinder(r, h):
volume = 3.1415 * r * r * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_rename_variable_cb
|
def volume_cylinder(p, h):
volume = 3.1415 * p * p * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_rename_variable_naive
|
def volume_cylinder(VAR_0, h):
volume = 3.1415 * VAR_0 * VAR_0 * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_rename_variable_rn
|
def volume_cylinder(D, h):
volume = 3.1415 * D * D * h
return volume
| 1 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_mul_div_variable
|
def volume_cylinder(r,h):
volume=3.1415/r*r*h
return volume
| 0 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
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 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
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 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
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 | 273 |
mbpp
|
def volume_cylinder(r,h):
volume=3.1415*r*r*h
return volume
|
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 | 273 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * n
|
transformation_dead_code_insert
|
def is_num_decagonal(n):
_i_4 = 0
while _i_4 < _i_4:
return 4 * n * n - 3 * n
return 4 * n * n - 3 * n
| 1 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * n
|
transformation_sub_add_variable
|
def is_num_decagonal(n):
return 4 * n * n + 3 * n
| 0 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * n
|
transformation_mul_div_variable
|
def is_num_decagonal(n):
return 4 / n * n - 3 * n
| 0 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * 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 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * n
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * 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 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * 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 | 276 |
mbpp
|
def is_num_decagonal(n):
return 4 * n * n - 3 * 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 | 276 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_dead_code_insert
|
def sub_list(nums1, nums2):
for _i_1 in range(0):
return list(result)
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_for_while_loop
|
def sub_list(nums1, nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_operand_swap
|
def sub_list(nums1, nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_rename_variable_cb
|
def sub_list(nums1, result2):
result = map(lambda x, y: x - y, nums1, result2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_rename_variable_naive
|
def sub_list(nums1, nums2):
result = map(lambda VAR_0, y: VAR_0 - y, nums1, nums2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_rename_variable_rn
|
def sub_list(nums1, nums2):
result = map(lambda x, C: x - C, nums1, nums2)
return list(result)
| 1 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_sub_add_variable
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x + y, nums1, nums2)
return list(result)
| 0 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(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 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(result)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(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 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(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 | 279 |
mbpp
|
def sub_list(nums1,nums2):
result = map(lambda x, y: x - y, nums1, nums2)
return list(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 | 279 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_dead_code_insert
|
def text_match_two_three(text):
_i_2 = 0
while _i_2 > _i_2:
patterns = "ab{2,3}"
import re
patterns = "ab{2,3}"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_for_while_loop
|
def text_match_two_three(text):
import re
patterns = "ab{2,3}"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_operand_swap
|
def text_match_two_three(text):
import re
patterns = "ab{2,3}"
if re.search(patterns, text):
return "Found a match!"
else:
return "Not matched!"
| 1 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_naive
|
def text_match_two_three(VAR_0):
import re
patterns = "ab{2,3}"
if re.search(patterns, VAR_0):
return "Found a match!"
else:
return "Not matched!"
| 1 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_rename_variable_rn
|
def text_match_two_three(H0b7):
import re
patterns = "ab{2,3}"
if re.search(patterns, H0b7):
return "Found a match!"
else:
return "Not matched!"
| 1 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 282 |
mbpp
|
def text_match_two_three(text):
import re
patterns = 'ab{2,3}'
if re.search(patterns, text):
return 'Found a match!'
else:
return('Not matched!')
|
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 | 282 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_dead_code_insert
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n * k):
_i_5 = 0
while _i_5 < _i_5:
if max_ending_here < 0:
max_ending_here = 0
max_ending_here = max_ending_here + a[i % n]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_for_while_loop
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
i = 0
while i < n * k:
max_ending_here = max_ending_here + a[i % n]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
i += 1
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_operand_swap
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n * k):
max_ending_here = max_ending_here + a[i % n]
if max_ending_here > max_so_far:
max_so_far = max_ending_here
if max_ending_here < 0:
max_ending_here = 0
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_rename_variable_cb
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
n2 = 0
for i in range(n * k):
n2 = n2 + a[i % n]
if max_so_far < n2:
max_so_far = n2
if n2 < 0:
n2 = 0
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_rename_variable_naive
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
VAR_0 = 0
for i in range(n * k):
VAR_0 = VAR_0 + a[i % n]
if max_so_far < VAR_0:
max_so_far = VAR_0
if VAR_0 < 0:
VAR_0 = 0
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_rename_variable_rn
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
sg6vV5539O72UnN = 0
for i in range(n * k):
sg6vV5539O72UnN = sg6vV5539O72UnN + a[i % n]
if max_so_far < sg6vV5539O72UnN:
max_so_far = sg6vV5539O72UnN
if sg6vV5539O72UnN < 0:
sg6vV5539O72UnN = 0
return max_so_far
| 1 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_add_sub_variable
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here - a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
| 0 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_sub_add_variable
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = +2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
| 0 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_mul_div_variable
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n/k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
| 0 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_lesser_greater_variable
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far > max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
| 0 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
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 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 0
return max_so_far
|
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 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 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 | 283 |
mbpp
|
def max_sub_array_sum_repeated(a, n, k):
max_so_far = -2147483648
max_ending_here = 0
for i in range(n*k):
max_ending_here = max_ending_here + a[i%n]
if (max_so_far < max_ending_here):
max_so_far = max_ending_here
if (max_ending_here < 0):
max_ending_here = 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 | 283 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
transformation_add_sub_variable
|
def square_Sum(n):
return int(2*n*(n-1)*(2*n+1)/3)
| 0 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
transformation_mul_div_variable
|
def square_Sum(n):
return int(2/n*(n+1)*(2*n+1)/3)
| 0 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
transformation_div_mul_variable
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)*3)
| 0 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
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 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
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 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
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 | 284 |
mbpp
|
def square_Sum(n):
return int(2*n*(n+1)*(2*n+1)/3)
|
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 | 284 |
mbpp
|
def max_length(list1):
max_length = max(len(x) for x in list1 )
max_list = max((x) for x in list1)
return(max_length, max_list)
|
transformation_dead_code_insert
|
def max_length(list1):
_i_9 = 0
if _i_9 > _i_9:
max_list = max((x) for x in list1)
max_length = max(len(x) for x in list1)
max_list = max((x) for x in list1)
return (max_length, max_list)
| 1 | 287 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.