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-... | 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-... | 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-... | 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-... | 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-Z... | 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):
... | 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):
... | 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):
... | 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):
... | 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):
... | 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-... | 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-... | 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-... | 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-... | 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.