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 last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 0
|
transformation_lesser_greater_variable
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n >= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 0
| 0 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 0
|
transformation_equalto_exclamation_variable
|
def last_Digit_Factorial(n):
if (n != 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 0
| 0 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 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 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 0
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 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 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 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 | 574 |
mbpp
|
def last_Digit_Factorial(n):
if (n == 0): return 1
elif (n <= 2): return n
elif (n == 3): return 6
elif (n == 4): return 4
else:
return 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 | 574 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_dead_code_insert
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
for _i_1 in range(0):
res = tuple()
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
res += (ele,)
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return res
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_for_while_loop
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
_ele_i = 0
while _ele_i < len(test_tuple):
ele = test_tuple[_ele_i]
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
res += (ele,)
_ele_i += 1
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return res
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_operand_swap
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
res += (ele,)
return res
res = even_ele(test_tuple, lambda x: 0 == x % 2)
return res
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_rename_variable_cb
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
result = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
result += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
result += (ele,)
return result
result = even_ele(test_tuple, lambda x: x % 2 == 0)
return result
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_rename_variable_naive
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
VAR_0 = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
VAR_0 += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
VAR_0 += (ele,)
return VAR_0
VAR_0 = even_ele(test_tuple, lambda x: x % 2 == 0)
return VAR_0
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_rename_variable_rn
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
N35 = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
N35 += (even_ele(ele, even_fnc),)
elif even_fnc(ele):
N35 += (ele,)
return N35
N35 = even_ele(test_tuple, lambda x: x % 2 == 0)
return N35
| 1 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_add_sub_variable
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res -= (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
| 0 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
return (res)
|
transformation_equalto_exclamation_variable
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 != 0)
return (res)
| 0 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
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 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
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 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
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 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
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 | 577 |
mbpp
|
def extract_even(test_tuple):
def even_ele(test_tuple, even_fnc):
res = tuple()
for ele in test_tuple:
if isinstance(ele, tuple):
res += (even_ele(ele, even_fnc), )
elif even_fnc(ele):
res += (ele, )
return res
res = even_ele(test_tuple, lambda x: x % 2 == 0)
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 | 577 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_dead_code_insert
|
def my_dict(dict1):
if bool(dict1):
while False:
return False
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_for_while_loop
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_operand_swap
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_rename_variable_cb
|
def my_dict(line):
if bool(line):
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_rename_variable_naive
|
def my_dict(VAR_0):
if bool(VAR_0):
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_rename_variable_rn
|
def my_dict(ar36z):
if bool(ar36z):
return False
else:
return True
| 1 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_true_false_variable
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return False
| 0 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_false_true_variable
|
def my_dict(dict1):
if bool(dict1):
return True
else:
return True
| 0 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
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 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
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 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
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 | 579 |
mbpp
|
def my_dict(dict1):
if bool(dict1):
return False
else:
return True
|
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 | 579 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_dead_code_insert
|
def big_diff(nums):
_i_8 = 0
if _i_8 < _i_8:
diff = max(nums) - min(nums)
diff = max(nums) - min(nums)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_for_while_loop
|
def big_diff(nums):
diff = max(nums) - min(nums)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_operand_swap
|
def big_diff(nums):
diff = max(nums) - min(nums)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_rename_variable_cb
|
def big_diff(line):
diff = max(line) - min(line)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_rename_variable_naive
|
def big_diff(VAR_0):
diff = max(VAR_0) - min(VAR_0)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_rename_variable_rn
|
def big_diff(EL4K):
diff = max(EL4K) - min(EL4K)
return diff
| 1 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_sub_add_variable
|
def big_diff(nums):
diff= max(nums)+min(nums)
return diff
| 0 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
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 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
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 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
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 | 585 |
mbpp
|
def big_diff(nums):
diff= max(nums)-min(nums)
return diff
|
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 | 585 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_dead_code_insert
|
def perfect_squares(a, b):
lists = []
for i in range(a, b + 1):
_i_7 = 0
while _i_7 > _i_7:
return lists
j = 1
while j * j <= i:
if j * j == i:
lists.append(i)
j = j + 1
i = i + 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_for_while_loop
|
def perfect_squares(a, b):
lists = []
i = a
while i < b + 1:
j = 1
while j * j <= i:
if j * j == i:
lists.append(i)
j = j + 1
i = i + 1
i += 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_operand_swap
|
def perfect_squares(a, b):
lists = []
for i in range(a, b + 1):
j = 1
while i >= j * j:
if j * j == i:
lists.append(i)
j = j + 1
i = i + 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_rename_variable_cb
|
def perfect_squares(a, b):
lists = []
for i in range(a, b + 1):
i2 = 1
while i2 * i2 <= i:
if i2 * i2 == i:
lists.append(i)
i2 = i2 + 1
i = i + 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_rename_variable_naive
|
def perfect_squares(a, b):
lists = []
for i in range(a, b + 1):
VAR_0 = 1
while VAR_0 * VAR_0 <= i:
if VAR_0 * VAR_0 == i:
lists.append(i)
VAR_0 = VAR_0 + 1
i = i + 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_rename_variable_rn
|
def perfect_squares(a, b):
lists = []
for i in range(a, b + 1):
F = 1
while F * F <= i:
if F * F == i:
lists.append(i)
F = F + 1
i = i + 1
return lists
| 1 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_add_sub_variable
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b-1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
| 0 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_mul_div_variable
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j/j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
| 0 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_lesser_greater_variable
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j >= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
| 0 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_equalto_exclamation_variable
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j != i:
lists.append(i)
j = j+1
i = i+1
return lists
| 0 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
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 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
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 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
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 | 586 |
mbpp
|
def perfect_squares(a, b):
lists=[]
for i in range (a,b+1):
j = 1;
while j*j <= i:
if j*j == i:
lists.append(i)
j = j+1
i = i+1
return lists
|
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 | 586 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_dead_code_insert
|
def min_Swaps(str1, str2):
count = 0
_i_2 = 0
while _i_2 > _i_2:
count = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
count += 1
if count % 2 == 0:
return count // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_for_while_loop
|
def min_Swaps(str1, str2):
count = 0
i = 0
while i < len(str1):
if str1[i] != str2[i]:
count += 1
i += 1
if count % 2 == 0:
return count // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_operand_swap
|
def min_Swaps(str1, str2):
count = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
count += 1
if 0 == count % 2:
return count // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_rename_variable_cb
|
def min_Swaps(str1, str2):
i2 = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
i2 += 1
if i2 % 2 == 0:
return i2 // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_rename_variable_naive
|
def min_Swaps(str1, str2):
VAR_0 = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
VAR_0 += 1
if VAR_0 % 2 == 0:
return VAR_0 // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_rename_variable_rn
|
def min_Swaps(str1, str2):
q4290 = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
q4290 += 1
if q4290 % 2 == 0:
return q4290 // 2
else:
return "Not Possible"
| 1 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_add_sub_variable
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count -= 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
| 0 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_div_mul_variable
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count */ 2)
else :
return ("Not Possible")
| 0 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_equalto_exclamation_variable
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 != 0 :
return (count // 2)
else :
return ("Not Possible")
| 0 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_exclamation_equalto_variable
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] == str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
| 0 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
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 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
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 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
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 | 592 |
mbpp
|
def min_Swaps(str1,str2) :
count = 0
for i in range(len(str1)) :
if str1[i] != str2[i] :
count += 1
if count % 2 == 0 :
return (count // 2)
else :
return ("Not Possible")
|
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 | 592 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_dead_code_insert
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
for _i_3 in range(0):
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if arr[i].a > arr[j].b and mcl[i] < mcl[j] + 1:
mcl[i] = mcl[j] + 1
for i in range(n):
if max < mcl[i]:
max = mcl[i]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_for_while_loop
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
i = 1
while i < n:
for j in range(0, i):
if arr[i].a > arr[j].b and mcl[i] < mcl[j] + 1:
mcl[i] = mcl[j] + 1
i += 1
for i in range(n):
if max < mcl[i]:
max = mcl[i]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_operand_swap
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if arr[i].a > arr[j].b and mcl[i] < mcl[j] + 1:
mcl[i] = mcl[j] + 1
for i in range(n):
if mcl[i] > max:
max = mcl[i]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_rename_variable_cb
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for j2 in range(n)]
for j2 in range(1, n):
for j in range(0, j2):
if arr[j2].a > arr[j].b and mcl[j2] < mcl[j] + 1:
mcl[j2] = mcl[j] + 1
for j2 in range(n):
if max < mcl[j2]:
max = mcl[j2]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_rename_variable_naive
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for VAR_0 in range(n)]
for VAR_0 in range(1, n):
for j in range(0, VAR_0):
if arr[VAR_0].a > arr[j].b and mcl[VAR_0] < mcl[j] + 1:
mcl[VAR_0] = mcl[j] + 1
for VAR_0 in range(n):
if max < mcl[VAR_0]:
max = mcl[VAR_0]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_rename_variable_rn
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for R in range(n)]
for R in range(1, n):
for j in range(0, R):
if arr[R].a > arr[j].b and mcl[R] < mcl[j] + 1:
mcl[R] = mcl[j] + 1
for R in range(n):
if max < mcl[R]:
max = mcl[R]
return max
| 1 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_add_sub_variable
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] - 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
| 0 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_lesser_greater_variable
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] > mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
| 0 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_greater_lesser_variable
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a < arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
| 0 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_and_or_variable
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b or
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
| 0 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
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 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
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 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
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 | 598 |
mbpp
|
def max_chain_length(arr, n):
class Pair(object):
def __init__(self, a, b):
self.a = a
self.b = b
max = 0
mcl = [1 for i in range(n)]
for i in range(1, n):
for j in range(0, i):
if (arr[i].a > arr[j].b and
mcl[i] < mcl[j] + 1):
mcl[i] = mcl[j] + 1
for i in range(n):
if (max < mcl[i]):
max = mcl[i]
return max
|
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 | 598 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_dead_code_insert
|
def get_ludic(n):
if False:
for i in range(1, n + 1):
ludics.append(i)
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while index != len(ludics):
first_ludic = ludics[index]
remove_index = index + first_ludic
while remove_index < len(ludics):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_for_while_loop
|
def get_ludic(n):
ludics = []
i = 1
while i < n + 1:
ludics.append(i)
i += 1
index = 1
while index != len(ludics):
first_ludic = ludics[index]
remove_index = index + first_ludic
while remove_index < len(ludics):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_operand_swap
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while len(ludics) != index:
first_ludic = ludics[index]
remove_index = index + first_ludic
while remove_index < len(ludics):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_rename_variable_cb
|
def get_ludic(n):
lines = []
for i in range(1, n + 1):
lines.append(i)
index = 1
while index != len(lines):
first_ludic = lines[index]
remove_index = index + first_ludic
while remove_index < len(lines):
lines.remove(lines[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return lines
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_rename_variable_naive
|
def get_ludic(n):
VAR_0 = []
for i in range(1, n + 1):
VAR_0.append(i)
index = 1
while index != len(VAR_0):
first_ludic = VAR_0[index]
remove_index = index + first_ludic
while remove_index < len(VAR_0):
VAR_0.remove(VAR_0[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return VAR_0
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_rename_variable_rn
|
def get_ludic(n):
O12696 = []
for i in range(1, n + 1):
O12696.append(i)
index = 1
while index != len(O12696):
first_ludic = O12696[index]
remove_index = index + first_ludic
while remove_index < len(O12696):
O12696.remove(O12696[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return O12696
| 1 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_add_sub_variable
|
def get_ludic(n):
ludics = []
for i in range(1, n - 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 0 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_sub_add_variable
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic + 1
index += 1
return ludics
| 0 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_lesser_greater_variable
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index > len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 0 | 600 |
mbpp
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index != len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
|
transformation_exclamation_equalto_variable
|
def get_ludic(n):
ludics = []
for i in range(1, n + 1):
ludics.append(i)
index = 1
while(index == len(ludics)):
first_ludic = ludics[index]
remove_index = index + first_ludic
while(remove_index < len(ludics)):
ludics.remove(ludics[remove_index])
remove_index = remove_index + first_ludic - 1
index += 1
return ludics
| 0 | 600 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.