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.