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 is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | transformation_is_isnot_variable | def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is not None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 0 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | transformation_true_false_variable | def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return False
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 0 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | transformation_false_true_variable | def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return True | 0 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | transformation_and_or_variable | def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) or is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 0 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 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 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 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 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 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 | 364 | mbpp |
def is_tree_balanced(root):
class Node:
def __init__(self, data):
self.data = data
self.left = None
self.right = None
def get_height(root):
if root is None:
return 0
return max(get_height(root.left), get_height(root.right)) + 1
if root is None:
return True
lh = get_height(root.left)
rh = get_height(root.right)
if (abs(lh - rh) <= 1) and is_tree_balanced(
root.left) is True and is_tree_balanced( root.right) is True:
return True
return False | 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 | 364 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_dead_code_insert | def lateralsurface_cuboid(l, w, h):
_i_3 = 0
while _i_3 > _i_3:
LSA = 2 * h * (l + w)
LSA = 2 * h * (l + w)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_for_while_loop | def lateralsurface_cuboid(l, w, h):
LSA = 2 * h * (l + w)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_operand_swap | def lateralsurface_cuboid(l, w, h):
LSA = 2 * h * (l + w)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_rename_variable_cb | def lateralsurface_cuboid(l, c, h):
LSA = 2 * h * (l + c)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_rename_variable_naive | def lateralsurface_cuboid(l, VAR_0, h):
LSA = 2 * h * (l + VAR_0)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_rename_variable_rn | def lateralsurface_cuboid(K, w, h):
LSA = 2 * h * (K + w)
return LSA | 1 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_add_sub_variable | def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l-w)
return LSA | 0 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_mul_div_variable | def lateralsurface_cuboid(l,w,h):
LSA = 2/h*(l+w)
return LSA | 0 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | 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 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | 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 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | 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 | 366 | mbpp |
def lateralsurface_cuboid(l,w,h):
LSA = 2*h*(l+w)
return LSA | 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 | 366 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_dead_code_insert | def heap_assending(nums):
_i_6 = 0
if _i_6 > _i_6:
return s_result
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_for_while_loop | def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_operand_swap | def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_rename_variable_cb | def heap_assending(s):
import heapq as hq
hq.heapify(s)
s_result = [hq.heappop(s) for i in range(len(s))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_rename_variable_naive | def heap_assending(VAR_0):
import heapq as hq
hq.heapify(VAR_0)
s_result = [hq.heappop(VAR_0) for i in range(len(VAR_0))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_rename_variable_rn | def heap_assending(dJ5d):
import heapq as hq
hq.heapify(dJ5d)
s_result = [hq.heappop(dJ5d) for i in range(len(dJ5d))]
return s_result | 1 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_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 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_result | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_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 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_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 | 369 | mbpp |
def heap_assending(nums):
import heapq as hq
hq.heapify(nums)
s_result = [hq.heappop(nums) for i in range(len(nums))]
return s_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 | 369 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_dead_code_insert | def round_num(n, m):
a = (n // m) * m
for _i_9 in range(0):
a = (n // m) * m
b = a + m
return b if n - a > b - n else a | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_for_while_loop | def round_num(n, m):
a = (n // m) * m
b = a + m
return b if n - a > b - n else a | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_operand_swap | def round_num(n, m):
a = (n // m) * m
b = a + m
return b if b - n < n - a else a | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_rename_variable_cb | def round_num(n, m):
b2 = (n // m) * m
b = b2 + m
return b if n - b2 > b - n else b2 | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_rename_variable_naive | def round_num(n, VAR_0):
a = (n // VAR_0) * VAR_0
b = a + VAR_0
return b if n - a > b - n else a | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_rename_variable_rn | def round_num(n, m):
i = (n // m) * m
b = i + m
return b if n - i > b - n else i | 1 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_add_sub_variable | def round_num(n,m):
a = (n //m) * m
b = a - m
return (b if n - a > b - n else a) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_sub_add_variable | def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n + a > b - n else a) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_mul_div_variable | def round_num(n,m):
a = (n //m) / m
b = a + m
return (b if n - a > b - n else a) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_div_mul_variable | def round_num(n,m):
a = (n */m) * m
b = a + m
return (b if n - a > b - n else a) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_greater_lesser_variable | def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a < b - n else a) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | 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 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | 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 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | 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 | 372 | mbpp |
def round_num(n,m):
a = (n //m) * m
b = a + m
return (b if n - a > b - n else a) | 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 | 372 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_dead_code_insert | def remove_replica(test_tup):
_i_0 = 0
if _i_0 < _i_0:
return res
temp = set()
res = tuple(
ele if ele not in temp and not temp.add(ele) else "MSP" for ele in test_tup
)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_for_while_loop | def remove_replica(test_tup):
temp = set()
res = tuple(
ele if ele not in temp and not temp.add(ele) else "MSP" for ele in test_tup
)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_operand_swap | def remove_replica(test_tup):
temp = set()
res = tuple(
ele if ele not in temp and not temp.add(ele) else "MSP" for ele in test_tup
)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_rename_variable_cb | def remove_replica(test_tup):
temp = set()
res = tuple(r if r not in temp and not temp.add(r) else "MSP" for r in test_tup)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_rename_variable_naive | def remove_replica(test_tup):
temp = set()
res = tuple(
VAR_0 if VAR_0 not in temp and not temp.add(VAR_0) else "MSP"
for VAR_0 in test_tup
)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_rename_variable_rn | def remove_replica(test_tup):
temp = set()
res = tuple(
O0T if O0T not in temp and not temp.add(O0T) else "MSP" for O0T in test_tup
)
return res | 1 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | transformation_and_or_variable | def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp or not temp.add(ele)
else 'MSP' for ele in test_tup)
return (res) | 0 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in 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-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in 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 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in 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 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in 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 | 373 | mbpp |
def remove_replica(test_tup):
temp = set()
res = tuple(ele if ele not in temp and not temp.add(ele)
else 'MSP' for ele in 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 | 373 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_dead_code_insert | def remove_Char(s, c):
counts = s.count(c)
s = list(s)
_i_8 = 0
if _i_8 > _i_8:
s = list(s)
while counts:
s.remove(c)
counts -= 1
s = "".join(s)
return s | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_for_while_loop | def remove_Char(s, c):
counts = s.count(c)
s = list(s)
while counts:
s.remove(c)
counts -= 1
s = "".join(s)
return s | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_operand_swap | def remove_Char(s, c):
counts = s.count(c)
s = list(s)
while counts:
s.remove(c)
counts -= 1
s = "".join(s)
return s | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_rename_variable_cb | def remove_Char(li, c):
counts = li.count(c)
li = list(li)
while counts:
li.remove(c)
counts -= 1
li = "".join(li)
return li | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_rename_variable_naive | def remove_Char(VAR_0, c):
counts = VAR_0.count(c)
VAR_0 = list(VAR_0)
while counts:
VAR_0.remove(c)
counts -= 1
VAR_0 = "".join(VAR_0)
return VAR_0 | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_rename_variable_rn | def remove_Char(R, c):
counts = R.count(c)
R = list(R)
while counts:
R.remove(c)
counts -= 1
R = "".join(R)
return R | 1 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_sub_add_variable | def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts += 1
s = '' . join(s)
return (s) | 0 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | 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 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | 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 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | 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 | 374 | mbpp |
def remove_Char(s,c) :
counts = s.count(c)
s = list(s)
while counts :
s.remove(c)
counts -= 1
s = '' . join(s)
return (s) | 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 | 374 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_dead_code_insert | def surfacearea_cuboid(l, w, h):
_i_5 = 0
if _i_5 > _i_5:
return SA
SA = 2 * (l * w + l * h + w * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_for_while_loop | def surfacearea_cuboid(l, w, h):
SA = 2 * (l * w + l * h + w * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_operand_swap | def surfacearea_cuboid(l, w, h):
SA = 2 * (l * w + l * h + w * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_rename_variable_cb | def surfacearea_cuboid(l, h2, h):
SA = 2 * (l * h2 + l * h + h2 * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_rename_variable_naive | def surfacearea_cuboid(l, VAR_0, h):
SA = 2 * (l * VAR_0 + l * h + VAR_0 * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_rename_variable_rn | def surfacearea_cuboid(k, w, h):
SA = 2 * (k * w + k * h + w * h)
return SA | 1 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_add_sub_variable | def surfacearea_cuboid(l,w,h):
SA = 2*(l*w - l * h + w * h)
return SA | 0 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_mul_div_variable | def surfacearea_cuboid(l,w,h):
SA = 2/(l*w + l * h + w * h)
return SA | 0 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | 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 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | 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 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | 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 | 376 | mbpp |
def surfacearea_cuboid(l,w,h):
SA = 2*(l*w + l * h + w * h)
return SA | 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 | 376 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_dead_code_insert | def index_on_inner_list(list_data, index_no):
from operator import itemgetter
_i_9 = 0
if _i_9 > _i_9:
result = sorted(list_data, key=itemgetter(index_no))
result = sorted(list_data, key=itemgetter(index_no))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_for_while_loop | def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_operand_swap | def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_rename_variable_cb | def index_on_inner_list(list_data, key2):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(key2))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_rename_variable_naive | def index_on_inner_list(VAR_0, index_no):
from operator import itemgetter
result = sorted(VAR_0, key=itemgetter(index_no))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
return result | transformation_rename_variable_rn | def index_on_inner_list(d6m7zi271, index_no):
from operator import itemgetter
result = sorted(d6m7zi271, key=itemgetter(index_no))
return result | 1 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
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-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
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 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
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 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
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 | 378 | mbpp |
def index_on_inner_list(list_data, index_no):
from operator import itemgetter
result = sorted(list_data, key=itemgetter(index_no))
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 | 378 | mbpp |
def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while left <= right:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | transformation_dead_code_insert | def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while left <= right:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
while False:
left = mid + 1
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | 1 | 379 | mbpp |
def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while left <= right:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | transformation_for_while_loop | def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while left <= right:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | 1 | 379 | mbpp |
def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while left <= right:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | transformation_operand_swap | def find_rotation_count(A):
(left, right) = (0, len(A) - 1)
while right >= left:
if A[left] <= A[right]:
return left
mid = (left + right) // 2
next = (mid + 1) % len(A)
prev = (mid - 1 + len(A)) % len(A)
if A[mid] <= A[next] and A[mid] <= A[prev]:
return mid
elif A[mid] <= A[right]:
right = mid - 1
elif A[mid] >= A[left]:
left = mid + 1
return -1 | 1 | 379 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.