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 position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_result | transformation_rename_variable_naive | def position_max(VAR_0):
max_val = max(VAR_0)
max_result = [i for i, j in enumerate(VAR_0) if j == max_val]
return max_result | 1 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_result | transformation_rename_variable_rn | def position_max(BOhW2):
max_val = max(BOhW2)
max_result = [i for i, j in enumerate(BOhW2) if j == max_val]
return max_result | 1 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_result | transformation_equalto_exclamation_variable | def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j != max_val]
return max_result | 0 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_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 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_result | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_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 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_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 | 197 | mbpp |
def position_max(list1):
max_val = max(list1)
max_result = [i for i, j in enumerate(list1) if j == max_val]
return max_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 | 197 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_dead_code_insert | def hamming_Distance(n1, n2):
x = n1 ^ n2
setBits = 0
_i_9 = 0
if _i_9 > _i_9:
setBits += x & 1
while x > 0:
setBits += x & 1
x >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_for_while_loop | def hamming_Distance(n1, n2):
x = n1 ^ n2
setBits = 0
while x > 0:
setBits += x & 1
x >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_operand_swap | def hamming_Distance(n1, n2):
x = n1 ^ n2
setBits = 0
while 0 < x:
setBits += x & 1
x >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_rename_variable_cb | def hamming_Distance(n1, n2):
bits = n1 ^ n2
setBits = 0
while bits > 0:
setBits += bits & 1
bits >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_rename_variable_naive | def hamming_Distance(n1, n2):
VAR_0 = n1 ^ n2
setBits = 0
while VAR_0 > 0:
setBits += VAR_0 & 1
VAR_0 >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_rename_variable_rn | def hamming_Distance(n1, n2):
y = n1 ^ n2
setBits = 0
while y > 0:
setBits += y & 1
y >>= 1
return setBits | 1 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_add_sub_variable | def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits -= x & 1
x >>= 1
return setBits | 0 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_greater_lesser_variable | def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x < 0) :
setBits += x & 1
x >>= 1
return setBits | 0 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | 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 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | 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 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | 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 | 200 | mbpp |
def hamming_Distance(n1,n2) :
x = n1 ^ n2
setBits = 0
while (x > 0) :
setBits += x & 1
x >>= 1
return setBits | 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 | 200 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_dead_code_insert | def count(s, c):
_i_5 = 0
if _i_5 < _i_5:
if s[i] == c:
res = res + 1
res = 0
for i in range(len(s)):
if s[i] == c:
res = res + 1
return res | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_for_while_loop | def count(s, c):
res = 0
i = 0
while i < len(s):
if s[i] == c:
res = res + 1
i += 1
return res | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_operand_swap | def count(s, c):
res = 0
for i in range(len(s)):
if c == s[i]:
res = res + 1
return res | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_rename_variable_cb | def count(s, c):
i2 = 0
for i in range(len(s)):
if s[i] == c:
i2 = i2 + 1
return i2 | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_rename_variable_naive | def count(s, c):
VAR_0 = 0
for i in range(len(s)):
if s[i] == c:
VAR_0 = VAR_0 + 1
return VAR_0 | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_rename_variable_rn | def count(s, c):
U35 = 0
for i in range(len(s)):
if s[i] == c:
U35 = U35 + 1
return U35 | 1 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_add_sub_variable | def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res - 1
return res | 0 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
return res | transformation_equalto_exclamation_variable | def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] != c):
res = res + 1
return res | 0 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
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 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
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 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
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 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
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 | 201 | mbpp |
def count(s,c) :
res = 0
for i in range(len(s)) :
if (s[i] == c):
res = res + 1
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 | 201 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_dead_code_insert | def inversion_elements(test_tup):
_i_9 = 0
while _i_9 > _i_9:
return res
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_for_while_loop | def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_operand_swap | def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_rename_variable_cb | def inversion_elements(test_tup):
res = tuple(list(map(lambda x2: ~x2, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_rename_variable_naive | def inversion_elements(test_tup):
res = tuple(list(map(lambda VAR_0: ~VAR_0, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(test_tup))))
return (res) | transformation_rename_variable_rn | def inversion_elements(test_tup):
res = tuple(list(map(lambda g: ~g, list(test_tup))))
return res | 1 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(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 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(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 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(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 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(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 | 202 | mbpp |
def inversion_elements(test_tup):
res = tuple(list(map(lambda x: ~x, list(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 | 202 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_dead_code_insert | def concatenate_elements(test_tup):
for _i_5 in range(0):
return res
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_for_while_loop | def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_operand_swap | def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_rename_variable_cb | def concatenate_elements(elements):
res = tuple(i + j for i, j in zip(elements, elements[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_rename_variable_naive | def concatenate_elements(VAR_0):
res = tuple(i + j for i, j in zip(VAR_0, VAR_0[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_rename_variable_rn | def concatenate_elements(Hx1YgF83):
res = tuple(i + j for i, j in zip(Hx1YgF83, Hx1YgF83[1:]))
return res | 1 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
return (res) | transformation_add_sub_variable | def concatenate_elements(test_tup):
res = tuple(i - j for i, j in zip(test_tup, test_tup[1:]))
return (res) | 0 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
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 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
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 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
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 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
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 | 203 | mbpp |
def concatenate_elements(test_tup):
res = tuple(i + j for i, j in zip(test_tup, test_tup[1:]))
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 | 203 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_dead_code_insert | def is_decimal(num):
for _i_5 in range(0):
result = num_fetch.search(num)
import re
num_fetch = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_for_while_loop | def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_operand_swap | def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_rename_variable_cb | def is_decimal(num):
import re
regex = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
result = regex.search(num)
return bool(result) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_rename_variable_naive | def is_decimal(num):
import re
VAR_0 = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
result = VAR_0.search(num)
return bool(result) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_rename_variable_rn | def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(.[0-9]{1,2})?$""")
h16502 = num_fetch.search(num)
return bool(h16502) | 1 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_add_sub_variable | def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]-(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | 0 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_sub_add_variable | def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0+9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | 0 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(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 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(result) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(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 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(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 | 205 | mbpp |
def is_decimal(num):
import re
num_fetch = re.compile(r"""^[0-9]+(\.[0-9]{1,2})?$""")
result = num_fetch.search(num)
return bool(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 | 205 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_dead_code_insert | def heap_replace(heap, a):
_i_4 = 0
if _i_4 < _i_4:
import heapq as hq
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 1 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_for_while_loop | def heap_replace(heap, a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 1 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_operand_swap | def heap_replace(heap, a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 1 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_rename_variable_naive | def heap_replace(VAR_0, a):
import heapq as hq
hq.heapify(VAR_0)
hq.heapreplace(VAR_0, a)
return VAR_0 | 1 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_rename_variable_rn | def heap_replace(v3Zu, a):
import heapq as hq
hq.heapify(v3Zu)
hq.heapreplace(v3Zu, a)
return v3Zu | 1 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 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 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 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 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 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 | 206 | mbpp |
def heap_replace(heap,a):
import heapq as hq
hq.heapify(heap)
hq.heapreplace(heap, a)
return heap | 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 | 206 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_dead_code_insert | def is_allowed_specific_char(string):
import re
if False:
return not bool(string)
get_char = re.compile(r"[^a-zA-Z0-9.]")
string = get_char.search(string)
return not bool(string) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_for_while_loop | def is_allowed_specific_char(string):
import re
get_char = re.compile(r"[^a-zA-Z0-9.]")
string = get_char.search(string)
return not bool(string) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_operand_swap | def is_allowed_specific_char(string):
import re
get_char = re.compile(r"[^a-zA-Z0-9.]")
string = get_char.search(string)
return not bool(string) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_rename_variable_cb | def is_allowed_specific_char(char):
import re
get_char = re.compile(r"[^a-zA-Z0-9.]")
char = get_char.search(char)
return not bool(char) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_rename_variable_naive | def is_allowed_specific_char(VAR_0):
import re
get_char = re.compile(r"[^a-zA-Z0-9.]")
VAR_0 = get_char.search(VAR_0)
return not bool(VAR_0) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_rename_variable_rn | def is_allowed_specific_char(bI3q7o):
import re
get_char = re.compile(r"[^a-zA-Z0-9.]")
bI3q7o = get_char.search(bI3q7o)
return not bool(bI3q7o) | 1 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_sub_add_variable | def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a+zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | 0 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | 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 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | 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 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | 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 | 207 | mbpp |
def is_allowed_specific_char(string):
import re
get_char = re.compile(r'[^a-zA-Z0-9.]')
string = get_char.search(string)
return not bool(string) | 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 | 207 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_dead_code_insert | def first_Repeated_Char(str):
_i_1 = 0
while _i_1 < _i_1:
h[ch] = 0
h = {}
for ch in str:
if ch in h:
return ch
else:
h[ch] = 0
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_for_while_loop | def first_Repeated_Char(str):
h = {}
_ch_i = 0
while _ch_i < len(str):
ch = str[_ch_i]
if ch in h:
return ch
else:
h[ch] = 0
_ch_i += 1
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_operand_swap | def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch
else:
h[ch] = 0
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_rename_variable_cb | def first_Repeated_Char(str):
h = {}
for line in str:
if line in h:
return line
else:
h[line] = 0
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_rename_variable_naive | def first_Repeated_Char(str):
h = {}
for VAR_0 in str:
if VAR_0 in h:
return VAR_0
else:
h[VAR_0] = 0
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_rename_variable_rn | def first_Repeated_Char(str):
h = {}
for Tz in str:
if Tz in h:
return Tz
else:
h[Tz] = 0
return "0" | 1 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_dissimilar_code_injection_0 | def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n] | 0 | 214 | mbpp |
def first_Repeated_Char(str):
h = {}
for ch in str:
if ch in h:
return ch;
else:
h[ch] = 0
return '\0' | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 214 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.