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 kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_dead_code_insert
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n - i - 1):
_i_5 = 0
if _i_5 > _i_5:
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] == arr[j + 1], arr[j]
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] == arr[j + 1], arr[j]
return arr[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_for_while_loop
|
def kth_element(arr, n, k):
i = 0
while i < n:
for j in range(0, n - i - 1):
if arr[j] > arr[j + 1]:
arr[j], arr[j + 1] == arr[j + 1], arr[j]
i += 1
return arr[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_operand_swap
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n - i - 1):
if arr[j + 1] < arr[j]:
arr[j], arr[j + 1] == arr[j + 1], arr[j]
return arr[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_rename_variable_cb
|
def kth_element(i2, n, k):
for i in range(n):
for j in range(0, n - i - 1):
if i2[j] > i2[j + 1]:
i2[j], i2[j + 1] == i2[j + 1], i2[j]
return i2[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_rename_variable_naive
|
def kth_element(VAR_0, n, k):
for i in range(n):
for j in range(0, n - i - 1):
if VAR_0[j] > VAR_0[j + 1]:
VAR_0[j], VAR_0[j + 1] == VAR_0[j + 1], VAR_0[j]
return VAR_0[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_rename_variable_rn
|
def kth_element(VJ3, n, k):
for i in range(n):
for j in range(0, n - i - 1):
if VJ3[j] > VJ3[j + 1]:
VJ3[j], VJ3[j + 1] == VJ3[j + 1], VJ3[j]
return VJ3[k - 1]
| 1 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_add_sub_variable
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j-1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
| 0 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_sub_add_variable
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n+i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
| 0 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_greater_lesser_variable
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] < arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
| 0 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_equalto_exclamation_variable
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] != arr[j+1], arr[j]
return arr[k-1]
| 0 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-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 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-1]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-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 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-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 | 98 |
mbpp
|
def kth_element(arr, n, k):
for i in range(n):
for j in range(0, n-i-1):
if arr[j] > arr[j+1]:
arr[j], arr[j+1] == arr[j+1], arr[j]
return arr[k-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 | 98 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_dead_code_insert
|
def snake_to_camel(word):
for _i_7 in range(0):
import re
import re
return "".join(x.capitalize() or "_" for x in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_for_while_loop
|
def snake_to_camel(word):
import re
return "".join(x.capitalize() or "_" for x in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_operand_swap
|
def snake_to_camel(word):
import re
return "".join(x.capitalize() or "_" for x in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_rename_variable_cb
|
def snake_to_camel(word):
import re
return "".join(x2.capitalize() or "_" for x2 in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_rename_variable_naive
|
def snake_to_camel(word):
import re
return "".join(VAR_0.capitalize() or "_" for VAR_0 in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_rename_variable_rn
|
def snake_to_camel(word):
import re
return "".join(P.capitalize() or "_" for P in word.split("_"))
| 1 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_or_and_variable
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() and '_' for x in word.split('_'))
| 0 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
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 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
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 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
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 | 99 |
mbpp
|
def snake_to_camel(word):
import re
return ''.join(x.capitalize() or '_' for x in word.split('_'))
|
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 | 99 |
mbpp
|
def count(lst):
return sum(lst)
|
transformation_dead_code_insert
|
def count(lst):
while False:
return sum(lst)
return sum(lst)
| 1 | 102 |
mbpp
|
def count(lst):
return sum(lst)
|
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 | 102 |
mbpp
|
def count(lst):
return sum(lst)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 102 |
mbpp
|
def count(lst):
return sum(lst)
|
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 | 102 |
mbpp
|
def count(lst):
return sum(lst)
|
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 | 102 |
mbpp
|
def count(lst):
return sum(lst)
|
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 | 102 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_dead_code_insert
|
def add_lists(test_list, test_tup):
_i_6 = 0
if _i_6 > _i_6:
return res
res = tuple(list(test_tup) + test_list)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_for_while_loop
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_operand_swap
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_rename_variable_cb
|
def add_lists(test_list, lines):
res = tuple(list(lines) + test_list)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_rename_variable_naive
|
def add_lists(VAR_0, test_tup):
res = tuple(list(test_tup) + VAR_0)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_rename_variable_rn
|
def add_lists(test_list, I0118f88):
res = tuple(list(I0118f88) + test_list)
return res
| 1 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + test_list)
return (res)
|
transformation_add_sub_variable
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) - test_list)
return (res)
| 0 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + 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 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + 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 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + 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 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + 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 | 103 |
mbpp
|
def add_lists(test_list, test_tup):
res = tuple(list(test_tup) + 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 | 103 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_dead_code_insert
|
def merge_sorted_list(num1, num2, num3):
import heapq
num1 = sorted(num1)
_i_1 = 0
if _i_1 > _i_1:
import heapq
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(num1, num2, num3)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_for_while_loop
|
def merge_sorted_list(num1, num2, num3):
import heapq
num1 = sorted(num1)
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(num1, num2, num3)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_operand_swap
|
def merge_sorted_list(num1, num2, num3):
import heapq
num1 = sorted(num1)
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(num1, num2, num3)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_rename_variable_cb
|
def merge_sorted_list(num1, num2, result2):
import heapq
num1 = sorted(num1)
num2 = sorted(num2)
result2 = sorted(result2)
result = heapq.merge(num1, num2, result2)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_rename_variable_naive
|
def merge_sorted_list(VAR_0, num2, num3):
import heapq
VAR_0 = sorted(VAR_0)
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(VAR_0, num2, num3)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
return list(result)
|
transformation_rename_variable_rn
|
def merge_sorted_list(aYMM, num2, num3):
import heapq
aYMM = sorted(aYMM)
num2 = sorted(num2)
num3 = sorted(num3)
result = heapq.merge(aYMM, num2, num3)
return list(result)
| 1 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
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 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
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 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
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 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
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 | 105 |
mbpp
|
def merge_sorted_list(num1,num2,num3):
import heapq
num1=sorted(num1)
num2=sorted(num2)
num3=sorted(num3)
result = heapq.merge(num1,num2,num3)
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 | 105 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_dead_code_insert
|
def odd_Equivalent(s, n):
for _i_7 in range(0):
count = 0
count = 0
for i in range(0, n):
if s[i] == "1":
count = count + 1
return count
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_for_while_loop
|
def odd_Equivalent(s, n):
count = 0
i = 0
while i < n:
if s[i] == "1":
count = count + 1
i += 1
return count
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_operand_swap
|
def odd_Equivalent(s, n):
count = 0
for i in range(0, n):
if "1" == s[i]:
count = count + 1
return count
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_rename_variable_cb
|
def odd_Equivalent(s, n):
i2 = 0
for i in range(0, n):
if s[i] == "1":
i2 = i2 + 1
return i2
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_rename_variable_naive
|
def odd_Equivalent(s, n):
VAR_0 = 0
for i in range(0, n):
if s[i] == "1":
VAR_0 = VAR_0 + 1
return VAR_0
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_rename_variable_rn
|
def odd_Equivalent(s, n):
q3t20 = 0
for i in range(0, n):
if s[i] == "1":
q3t20 = q3t20 + 1
return q3t20
| 1 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_add_sub_variable
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count - 1
return count
| 0 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_equalto_exclamation_variable
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] != '1'):
count = count + 1
return count
| 0 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
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 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
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 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
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 | 106 |
mbpp
|
def odd_Equivalent(s,n):
count=0
for i in range(0,n):
if (s[i] == '1'):
count = count + 1
return count
|
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 | 106 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_dead_code_insert
|
def assign_freq(test_list):
from collections import Counter
_i_2 = 0
if _i_2 < _i_2:
return str(res)
res = [(*key, val) for key, val in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_for_while_loop
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_operand_swap
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_rename_variable_cb
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, value) for key, value in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_rename_variable_naive
|
def assign_freq(test_list):
from collections import Counter
res = [(*VAR_0, val) for VAR_0, val in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_rename_variable_rn
|
def assign_freq(test_list):
from collections import Counter
res = [(*R7f, val) for R7f, val in Counter(test_list).items()]
return str(res)
| 1 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_mul_div_variable
|
def assign_freq(test_list):
from collections import Counter
res = [(/key, val) for key, val in Counter(test_list).items()]
return (str(res))
| 0 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(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 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(res))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(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 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(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 | 111 |
mbpp
|
def assign_freq(test_list):
from collections import Counter
res = [(*key, val) for key, val in Counter(test_list).items()]
return (str(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 | 111 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_dead_code_insert
|
def empty_dit(list1):
_i_1 = 0
while _i_1 < _i_1:
return empty_dit
empty_dit = all(not d for d in list1)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_for_while_loop
|
def empty_dit(list1):
empty_dit = all(not d for d in list1)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_operand_swap
|
def empty_dit(list1):
empty_dit = all(not d for d in list1)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_rename_variable_cb
|
def empty_dit(lines):
empty_dit = all(not d for d in lines)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_rename_variable_naive
|
def empty_dit(VAR_0):
empty_dit = all(not d for d in VAR_0)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_rename_variable_rn
|
def empty_dit(E4187):
empty_dit = all(not d for d in E4187)
return empty_dit
| 1 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
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 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
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 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
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 | 112 |
mbpp
|
def empty_dit(list1):
empty_dit=all(not d for d in list1)
return empty_dit
|
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 | 112 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
transformation_dead_code_insert
|
def string_to_list(string):
while False:
return lst
lst = list(string.split(" "))
return lst
| 1 | 115 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
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 | 115 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 115 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
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 | 115 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
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 | 115 |
mbpp
|
def string_to_list(string):
lst = list(string.split(" "))
return lst
|
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 | 115 |
mbpp
|
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR)
|
transformation_dead_code_insert
|
def search(arr, n):
XOR = 0
_i_8 = 0
while _i_8 < _i_8:
XOR = 0
for i in range(n):
XOR = XOR ^ arr[i]
return XOR
| 1 | 116 |
mbpp
|
def search(arr,n) :
XOR = 0
for i in range(n) :
XOR = XOR ^ arr[i]
return (XOR)
|
transformation_for_while_loop
|
def search(arr, n):
XOR = 0
i = 0
while i < n:
XOR = XOR ^ arr[i]
i += 1
return XOR
| 1 | 116 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.