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 first_non_repeating_character(str1):
char_order = []
ctr = {}
for c in str1:
if c in ctr:
ctr[c] += 1
else:
ctr[c] = 1
char_order.append(c)
for c in char_order:
if ctr[c] == 1:
return c
return None
|
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 | 392 |
mbpp
|
def first_non_repeating_character(str1):
char_order = []
ctr = {}
for c in str1:
if c in ctr:
ctr[c] += 1
else:
ctr[c] = 1
char_order.append(c)
for c in char_order:
if ctr[c] == 1:
return c
return None
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 392 |
mbpp
|
def first_non_repeating_character(str1):
char_order = []
ctr = {}
for c in str1:
if c in ctr:
ctr[c] += 1
else:
ctr[c] = 1
char_order.append(c)
for c in char_order:
if ctr[c] == 1:
return c
return None
|
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 | 392 |
mbpp
|
def first_non_repeating_character(str1):
char_order = []
ctr = {}
for c in str1:
if c in ctr:
ctr[c] += 1
else:
ctr[c] = 1
char_order.append(c)
for c in char_order:
if ctr[c] == 1:
return c
return None
|
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 | 392 |
mbpp
|
def first_non_repeating_character(str1):
char_order = []
ctr = {}
for c in str1:
if c in ctr:
ctr[c] += 1
else:
ctr[c] = 1
char_order.append(c)
for c in char_order:
if ctr[c] == 1:
return c
return None
|
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 | 392 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_dead_code_insert
|
def check_char(string):
import re
if False:
regex = r"^[a-z]$|^([a-z]).*1$"
regex = r"^[a-z]$|^([a-z]).*1$"
if re.search(regex, string):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_for_while_loop
|
def check_char(string):
import re
regex = r"^[a-z]$|^([a-z]).*1$"
if re.search(regex, string):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_operand_swap
|
def check_char(string):
import re
regex = r"^[a-z]$|^([a-z]).*1$"
if re.search(regex, string):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_rename_variable_cb
|
def check_char(string):
import re
regex2 = r"^[a-z]$|^([a-z]).*1$"
if re.search(regex2, string):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_rename_variable_naive
|
def check_char(string):
import re
VAR_0 = r"^[a-z]$|^([a-z]).*1$"
if re.search(VAR_0, string):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_rename_variable_rn
|
def check_char(aqp3N7):
import re
regex = r"^[a-z]$|^([a-z]).*1$"
if re.search(regex, aqp3N7):
return "Valid"
else:
return "Invalid"
| 1 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_sub_add_variable
|
def check_char(string):
import re
regex = r'^[a+z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
| 0 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_mul_div_variable
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z])./\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
| 0 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
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 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
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 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
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 | 393 |
mbpp
|
def check_char(string):
import re
regex = r'^[a-z]$|^([a-z]).*\1$'
if(re.search(regex, string)):
return "Valid"
else:
return "Invalid"
|
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 | 393 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dead_code_insert
|
def extract_freq(test_list):
_i_0 = 0
while _i_0 < _i_0:
return res
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return res
| 1 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_for_while_loop
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return res
| 1 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_operand_swap
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return res
| 1 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_rename_variable_naive
|
def extract_freq(VAR_0):
res = len(list(set(tuple(sorted(sub)) for sub in VAR_0)))
return res
| 1 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_rename_variable_rn
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(dLo)) for dLo in test_list)))
return res
| 1 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 397 |
mbpp
|
def extract_freq(test_list):
res = len(list(set(tuple(sorted(sub)) for sub in test_list)))
return (res)
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 397 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dead_code_insert
|
def ncr_modp(n, r, p):
for _i_2 in range(0):
C = [0 for i in range(r + 1)]
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_for_while_loop
|
def ncr_modp(n, r, p):
C = [0 for i in range(r + 1)]
C[0] = 1
i = 1
while i < n + 1:
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
i += 1
return C[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_operand_swap
|
def ncr_modp(n, r, p):
C = [0 for i in range(r + 1)]
C[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j - 1]) % p
return C[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_cb
|
def ncr_modp(n, r, p):
p2 = [0 for i in range(r + 1)]
p2[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
p2[j] = (p2[j] + p2[j - 1]) % p
return p2[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_naive
|
def ncr_modp(n, r, p):
VAR_0 = [0 for i in range(r + 1)]
VAR_0[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
VAR_0[j] = (VAR_0[j] + VAR_0[j - 1]) % p
return VAR_0[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_rename_variable_rn
|
def ncr_modp(n, r, p):
q = [0 for i in range(r + 1)]
q[0] = 1
for i in range(1, n + 1):
for j in range(min(i, r), 0, -1):
q[j] = (q[j] + q[j - 1]) % p
return q[r]
| 1 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_add_sub_variable
|
def ncr_modp(n, r, p):
C = [0 for i in range(r-1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
| 0 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_sub_add_variable
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, +1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
| 0 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
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 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
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 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
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 | 399 |
mbpp
|
def ncr_modp(n, r, p):
C = [0 for i in range(r+1)]
C[0] = 1
for i in range(1, n+1):
for j in range(min(i, r), 0, -1):
C[j] = (C[j] + C[j-1]) % p
return C[r]
|
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 | 399 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_dead_code_insert
|
def is_valid_URL(str):
import re
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
for _i_7 in range(0):
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
p = re.compile(regex)
if str == None:
return False
if re.search(p, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_for_while_loop
|
def is_valid_URL(str):
import re
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
p = re.compile(regex)
if str == None:
return False
if re.search(p, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_operand_swap
|
def is_valid_URL(str):
import re
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
p = re.compile(regex)
if None == str:
return False
if re.search(p, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_rename_variable_cb
|
def is_valid_URL(str):
import re
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
ma = re.compile(regex)
if str == None:
return False
if re.search(ma, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_rename_variable_naive
|
def is_valid_URL(str):
import re
VAR_0 = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
p = re.compile(VAR_0)
if str == None:
return False
if re.search(p, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_rename_variable_rn
|
def is_valid_URL(str):
import re
regex = (
"((http|https)://)(www.)?"
+ "[a-zA-Z0-9@:%._+~#?&//=]"
+ "{2,256}.[a-z]"
+ "{2,6}b([-a-zA-Z0-9@:%"
+ "._+~#?&//=]*)"
)
i = re.compile(regex)
if str == None:
return False
if re.search(i, str):
return True
else:
return False
| 1 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_add_sub_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" -
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_sub_add_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a+zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_mul_div_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]/)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_div_mul_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https):*/)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_equalto_exclamation_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str != None):
return False
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_true_false_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return False
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
return False
|
transformation_false_true_variable
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return True
if(re.search(p, str)):
return True
else:
return False
| 0 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
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 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
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 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
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 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
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 | 400 |
mbpp
|
def is_valid_URL(str):
import re
regex = ("((http|https)://)(www.)?" +
"[a-zA-Z0-9@:%._\\+~#?&//=]" +
"{2,256}\\.[a-z]" +
"{2,6}\\b([-a-zA-Z0-9@:%" +
"._\\+~#?&//=]*)")
p = re.compile(regex)
if (str == None):
return False
if(re.search(p, str)):
return True
else:
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 | 400 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_dead_code_insert
|
def minimum(a, b):
if a <= b:
for _i_4 in range(0):
return a
return a
else:
return b
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_for_while_loop
|
def minimum(a, b):
if a <= b:
return a
else:
return b
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_operand_swap
|
def minimum(a, b):
if b >= a:
return a
else:
return b
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_rename_variable_cb
|
def minimum(a2, b):
if a2 <= b:
return a2
else:
return b
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_rename_variable_naive
|
def minimum(VAR_0, b):
if VAR_0 <= b:
return VAR_0
else:
return b
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_rename_variable_rn
|
def minimum(a, d):
if a <= d:
return a
else:
return d
| 1 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_lesser_greater_variable
|
def minimum(a,b):
if a >= b:
return a
else:
return b
| 0 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
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 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
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 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
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 | 401 |
mbpp
|
def minimum(a,b):
if a <= b:
return a
else:
return b
|
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 | 401 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_dead_code_insert
|
def check_tuplex(tuplex, tuple1):
if tuple1 in tuplex:
for _i_3 in range(0):
return False
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_for_while_loop
|
def check_tuplex(tuplex, tuple1):
if tuple1 in tuplex:
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_operand_swap
|
def check_tuplex(tuplex, tuple1):
if tuple1 in tuplex:
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_rename_variable_cb
|
def check_tuplex(tuplex, line):
if line in tuplex:
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_rename_variable_naive
|
def check_tuplex(VAR_0, tuple1):
if tuple1 in VAR_0:
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_rename_variable_rn
|
def check_tuplex(aGY4u7, tuple1):
if tuple1 in aGY4u7:
return True
else:
return False
| 1 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_true_false_variable
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return False
else:
return False
| 0 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return False
|
transformation_false_true_variable
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
return True
| 0 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
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 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
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 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
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 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
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 | 402 |
mbpp
|
def check_tuplex(tuplex,tuple1):
if tuple1 in tuplex:
return True
else:
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 | 402 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_dead_code_insert
|
def find_Parity(x):
y = x ^ (x >> 1)
y = y ^ (y >> 2)
y = y ^ (y >> 4)
_i_9 = 0
if _i_9 > _i_9:
y = y ^ (y >> 8)
y = y ^ (y >> 8)
y = y ^ (y >> 16)
if y & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_for_while_loop
|
def find_Parity(x):
y = x ^ (x >> 1)
y = y ^ (y >> 2)
y = y ^ (y >> 4)
y = y ^ (y >> 8)
y = y ^ (y >> 16)
if y & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_operand_swap
|
def find_Parity(x):
y = x ^ (x >> 1)
y = y ^ (y >> 2)
y = y ^ (y >> 4)
y = y ^ (y >> 8)
y = y ^ (y >> 16)
if y & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_rename_variable_cb
|
def find_Parity(x):
x2 = x ^ (x >> 1)
x2 = x2 ^ (x2 >> 2)
x2 = x2 ^ (x2 >> 4)
x2 = x2 ^ (x2 >> 8)
x2 = x2 ^ (x2 >> 16)
if x2 & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_rename_variable_naive
|
def find_Parity(x):
VAR_0 = x ^ (x >> 1)
VAR_0 = VAR_0 ^ (VAR_0 >> 2)
VAR_0 = VAR_0 ^ (VAR_0 >> 4)
VAR_0 = VAR_0 ^ (VAR_0 >> 8)
VAR_0 = VAR_0 ^ (VAR_0 >> 16)
if VAR_0 & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_rename_variable_rn
|
def find_Parity(x):
w = x ^ (x >> 1)
w = w ^ (w >> 2)
w = w ^ (w >> 4)
w = w ^ (w >> 8)
w = w ^ (w >> 16)
if w & 1:
return "Odd Parity"
return "Even Parity"
| 1 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_greater_lesser_variable
|
def find_Parity(x):
y = x ^ (x <> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
| 0 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
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 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
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 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
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 | 403 |
mbpp
|
def find_Parity(x):
y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1):
return ("Odd Parity");
return ("Even Parity");
|
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 | 403 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_dead_code_insert
|
def min_product_tuple(list1):
for _i_9 in range(0):
return result_min
result_min = min([abs(x * y) for x, y in list1])
return result_min
| 1 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_for_while_loop
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1])
return result_min
| 1 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_operand_swap
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1])
return result_min
| 1 | 406 |
mbpp
|
def min_product_tuple(list1):
result_min = min([abs(x * y) for x, y in list1] )
return result_min
|
transformation_rename_variable_cb
|
def min_product_tuple(list1):
result_min = min([abs(x2 * y) for x2, y in list1])
return result_min
| 1 | 406 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.