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 remove_duplicate(list1):
import itertools
list.sort(list1)
remove_duplicate = list(list1 for list1,_ in itertools.groupby(list1))
return remove_duplicate | 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 | 709 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_dead_code_insert | def check_valid(test_tup):
for _i_2 in range(0):
return res
res = not any(map(lambda ele: not ele, test_tup))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_for_while_loop | def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_operand_swap | def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_rename_variable_cb | def check_valid(lines):
res = not any(map(lambda ele: not ele, lines))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_rename_variable_naive | def check_valid(test_tup):
res = not any(map(lambda VAR_0: not VAR_0, test_tup))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
return (res) | transformation_rename_variable_rn | def check_valid(test_tup):
res = not any(map(lambda au4: not au4, test_tup))
return res | 1 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
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-... | 0 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
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 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
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 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
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 | 710 | mbpp |
def check_valid(test_tup):
res = not any(map(lambda ele: not ele, test_tup))
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 | 710 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_dead_code_insert | def rombus_perimeter(a):
_i_0 = 0
if _i_0 > _i_0:
return perimeter
perimeter = 4 * a
return perimeter | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_for_while_loop | def rombus_perimeter(a):
perimeter = 4 * a
return perimeter | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_operand_swap | def rombus_perimeter(a):
perimeter = 4 * a
return perimeter | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_rename_variable_cb | def rombus_perimeter(a):
a2 = 4 * a
return a2 | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_rename_variable_naive | def rombus_perimeter(VAR_0):
perimeter = 4 * VAR_0
return perimeter | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_rename_variable_rn | def rombus_perimeter(a):
O6en1884Y = 4 * a
return O6en1884Y | 1 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_mul_div_variable | def rombus_perimeter(a):
perimeter=4/a
return perimeter | 0 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | 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-... | 0 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | 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 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | 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 | 713 | mbpp |
def rombus_perimeter(a):
perimeter=4*a
return perimeter | 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 | 713 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_dead_code_insert | def alternate_elements(list1):
for _i_2 in range(0):
for item in list1[::2]:
result.append(item)
result = []
for item in list1[::2]:
result.append(item)
return result | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_for_while_loop | def alternate_elements(list1):
result = []
_item_i = 0
while _item_i < len(list1[::2]):
item = list1[::2][_item_i]
result.append(item)
_item_i += 1
return result | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_operand_swap | def alternate_elements(list1):
result = []
for item in list1[::2]:
result.append(item)
return result | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_rename_variable_cb | def alternate_elements(list1):
result2 = []
for item in list1[::2]:
result2.append(item)
return result2 | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_rename_variable_naive | def alternate_elements(list1):
VAR_0 = []
for item in list1[::2]:
VAR_0.append(item)
return VAR_0 | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_rename_variable_rn | def alternate_elements(list1):
d6k7w2 = []
for item in list1[::2]:
d6k7w2.append(item)
return d6k7w2 | 1 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return 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-... | 0 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return result | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return 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 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return 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 | 715 | mbpp |
def alternate_elements(list1):
result=[]
for item in list1[::2]:
result.append(item)
return 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 | 715 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_dead_code_insert | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
while False:
M = 100
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_for_while_loop | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
i = 1
while i < N:
dp[i][0] = dp[i - 1][0] + cost[i][0]
i += 1
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_operand_swap | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_rename_variable_cb | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i2 in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i2 in range(1, N):
dp[i2][0] = dp[i2 - 1][0] + cost[i2][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i2 in range(1, N):
fo... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_rename_variable_naive | def maxAverageOfPath(cost, VAR_0):
M = 100
dp = [[0 for i in range(VAR_0 + 1)] for j in range(VAR_0 + 1)]
dp[0][0] = cost[0][0]
for i in range(1, VAR_0):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, VAR_0):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, ... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_rename_variable_rn | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for e in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for e in range(1, N):
dp[e][0] = dp[e - 1][0] + cost[e][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for e in range(1, N):
for j in... | 1 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_add_sub_variable | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N - 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_sub_add_variable | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i + 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_mul_div_variable | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_div_mul_variable | def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 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-... | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 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 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 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 | 718 | mbpp |
def maxAverageOfPath(cost, N):
M = 100
dp = [[0 for i in range(N + 1)] for j in range(N + 1)]
dp[0][0] = cost[0][0]
for i in range(1, N):
dp[i][0] = dp[i - 1][0] + cost[i][0]
for j in range(1, N):
dp[0][j] = dp[0][j - 1] + cost[0][j]
for i in range(1, N):
for j in range(1, N):
dp[i][j] = max(d... | 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 | 718 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_dead_code_insert | def filter_data(students, h, w):
if False:
return result
result = {k: s for k, s in students.items() if s[0] >= h and s[1] >= w}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_for_while_loop | def filter_data(students, h, w):
result = {k: s for k, s in students.items() if s[0] >= h and s[1] >= w}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_operand_swap | def filter_data(students, h, w):
result = {k: s for k, s in students.items() if h <= s[0] and s[1] >= w}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_rename_variable_cb | def filter_data(students, h, w):
result = {k: v for k, v in students.items() if v[0] >= h and v[1] >= w}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_rename_variable_naive | def filter_data(students, h, w):
result = {
k: VAR_0 for k, VAR_0 in students.items() if VAR_0[0] >= h and VAR_0[1] >= w
}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_rename_variable_rn | def filter_data(students, h, w):
result = {k: X for k, X in students.items() if X[0] >= h and X[1] >= w}
return result | 1 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_greater_lesser_variable | def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] <=h and s[1] >=w}
return result | 0 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_and_or_variable | def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h or s[1] >=w}
return result | 0 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return 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-... | 0 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return result | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return 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 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return 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 | 719 | mbpp |
def filter_data(students,h,w):
result = {k: s for k, s in students.items() if s[0] >=h and s[1] >=w}
return 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 | 719 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_dead_code_insert | def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_for_while_loop | def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_operand_swap | def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_rename_variable_cb | def power_base_sum(base, power):
return sum([int(pr) for pr in str(pow(base, power))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_rename_variable_naive | def power_base_sum(base, VAR_0):
return sum([int(i) for i in str(pow(base, VAR_0))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_rename_variable_rn | def power_base_sum(HkK5, power):
return sum([int(i) for i in str(pow(HkK5, power))]) | 1 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 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-... | 0 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 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 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 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 | 721 | mbpp |
def power_base_sum(base, power):
return sum([int(i) for i in str(pow(base, power))]) | 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 | 721 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_dead_code_insert | def extract_quotation(text1):
for _i_7 in range(0):
return re.findall(r'"(.*?)"', text1)
import re
return re.findall(r'"(.*?)"', text1) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_for_while_loop | def extract_quotation(text1):
import re
return re.findall(r'"(.*?)"', text1) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_operand_swap | def extract_quotation(text1):
import re
return re.findall(r'"(.*?)"', text1) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_rename_variable_cb | def extract_quotation(line):
import re
return re.findall(r'"(.*?)"', line) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_rename_variable_naive | def extract_quotation(VAR_0):
import re
return re.findall(r'"(.*?)"', VAR_0) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_rename_variable_rn | def extract_quotation(Ki53S):
import re
return re.findall(r'"(.*?)"', Ki53S) | 1 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_mul_div_variable | def extract_quotation(text1):
import re
return (re.findall(r'"(./?)"', text1)) | 0 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | 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-... | 0 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | 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 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | 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 | 722 | mbpp |
def extract_quotation(text1):
import re
return (re.findall(r'"(.*?)"', text1)) | 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 | 722 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_dead_code_insert | def remove_char(S):
while False:
return result
import re
result = re.sub("[W_]+", "", S)
return result | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_for_while_loop | def remove_char(S):
import re
result = re.sub("[W_]+", "", S)
return result | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_operand_swap | def remove_char(S):
import re
result = re.sub("[W_]+", "", S)
return result | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_rename_variable_cb | def remove_char(result2):
import re
result = re.sub("[W_]+", "", result2)
return result | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_rename_variable_naive | def remove_char(VAR_0):
import re
result = re.sub("[W_]+", "", VAR_0)
return result | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_rename_variable_rn | def remove_char(S):
import re
Dy2vex = re.sub("[W_]+", "", S)
return Dy2vex | 1 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_add_sub_variable | def remove_char(S):
import re
result = re.sub('[\W_]-', '', S)
return result | 0 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return 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-... | 0 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return result | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return 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 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return 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 | 724 | mbpp |
def remove_char(S):
import re
result = re.sub('[\W_]+', '', S)
return 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 | 724 | mbpp |
def sum_list(lst1,lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list | transformation_dead_code_insert | def sum_list(lst1, lst2):
while False:
return res_list
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list | 1 | 725 | mbpp |
def sum_list(lst1,lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list | transformation_for_while_loop | def sum_list(lst1, lst2):
res_list = [lst1[i] + lst2[i] for i in range(len(lst1))]
return res_list | 1 | 725 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.