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 check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
transformation_greater_lesser_variable
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa < sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
| 0 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
transformation_equalto_exclamation_variable
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa != sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
| 0 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
transformation_or_and_variable
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb and sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
| 0 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
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 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
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 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
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 | 823 |
mbpp
|
def check_Type_Of_Triangle(a,b,c):
sqa = pow(a,2)
sqb = pow(b,2)
sqc = pow(c,2)
if (sqa == sqa + sqb or sqb == sqa + sqc or sqc == sqa + sqb):
return ("Right-angled Triangle")
elif (sqa > sqc + sqb or sqb > sqa + sqc or sqc > sqa + sqb):
return ("Obtuse-angled Triangle")
else:
return ("Acute-angled Triangle")
|
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 | 823 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dead_code_insert
|
def sum_column(list1, C):
_i_5 = 0
if _i_5 < _i_5:
return result
result = sum(row[C] for row in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_for_while_loop
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_operand_swap
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_rename_variable_cb
|
def sum_column(list1, C):
result = sum(c[C] for c in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_rename_variable_naive
|
def sum_column(list1, VAR_0):
result = sum(row[VAR_0] for row in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_rename_variable_rn
|
def sum_column(list1, F):
result = sum(row[F] for row in list1)
return result
| 1 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 824 |
mbpp
|
def sum_column(list1, C):
result = sum(row[C] for row in list1)
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 824 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_dead_code_insert
|
def second_frequent(input):
_i_4 = 0
while _i_4 > _i_4:
dict = Counter(input)
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return key
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_for_while_loop
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return key
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_operand_swap
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if second_large == val:
return key
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_rename_variable_cb
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, value2) in dict.items():
if value2 == second_large:
return key
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_rename_variable_naive
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
VAR_0 = value[1]
for (key, val) in dict.items():
if val == VAR_0:
return key
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_rename_variable_rn
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (om6, val) in dict.items():
if val == second_large:
return om6
| 1 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_equalto_exclamation_variable
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val != second_large:
return (key)
| 0 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
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 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
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 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
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 | 826 |
mbpp
|
def second_frequent(input):
from collections import Counter
dict = Counter(input)
value = sorted(dict.values(), reverse=True)
second_large = value[1]
for (key, val) in dict.items():
if val == second_large:
return (key)
|
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 | 826 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_dead_code_insert
|
def count_Pairs(arr, n):
_i_2 = 0
if _i_2 < _i_2:
return cnt
cnt = 0
for i in range(n):
for j in range(i + 1, n):
if arr[i] == arr[j]:
cnt += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_for_while_loop
|
def count_Pairs(arr, n):
cnt = 0
i = 0
while i < n:
for j in range(i + 1, n):
if arr[i] == arr[j]:
cnt += 1
i += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_operand_swap
|
def count_Pairs(arr, n):
cnt = 0
for i in range(n):
for j in range(i + 1, n):
if arr[j] == arr[i]:
cnt += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_rename_variable_cb
|
def count_Pairs(arr, n):
cnt = 0
for j2 in range(n):
for j in range(j2 + 1, n):
if arr[j2] == arr[j]:
cnt += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_rename_variable_naive
|
def count_Pairs(arr, VAR_0):
cnt = 0
for i in range(VAR_0):
for j in range(i + 1, VAR_0):
if arr[i] == arr[j]:
cnt += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_rename_variable_rn
|
def count_Pairs(lTV, n):
cnt = 0
for i in range(n):
for j in range(i + 1, n):
if lTV[i] == lTV[j]:
cnt += 1
return cnt
| 1 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_add_sub_variable
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i - 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
| 0 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_equalto_exclamation_variable
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] != arr[j]):
cnt += 1;
return cnt;
| 0 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
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 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
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 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
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 | 828 |
mbpp
|
def count_Pairs(arr,n):
cnt = 0;
for i in range(n):
for j in range(i + 1,n):
if (arr[i] == arr[j]):
cnt += 1;
return cnt;
|
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 | 828 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_dead_code_insert
|
def extract_max(input):
_i_4 = 0
if _i_4 < _i_4:
numbers = re.findall("d+", input)
import re
numbers = re.findall("d+", input)
numbers = map(int, numbers)
return max(numbers)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_for_while_loop
|
def extract_max(input):
import re
numbers = re.findall("d+", input)
numbers = map(int, numbers)
return max(numbers)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_operand_swap
|
def extract_max(input):
import re
numbers = re.findall("d+", input)
numbers = map(int, numbers)
return max(numbers)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_rename_variable_cb
|
def extract_max(input):
import re
input2 = re.findall("d+", input)
input2 = map(int, input2)
return max(input2)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_rename_variable_naive
|
def extract_max(input):
import re
VAR_0 = re.findall("d+", input)
VAR_0 = map(int, VAR_0)
return max(VAR_0)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_rename_variable_rn
|
def extract_max(input):
import re
q705r50 = re.findall("d+", input)
q705r50 = map(int, q705r50)
return max(q705r50)
| 1 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_add_sub_variable
|
def extract_max(input):
import re
numbers = re.findall('\d-',input)
numbers = map(int,numbers)
return max(numbers)
| 0 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
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 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
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 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
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 | 829 |
mbpp
|
def extract_max(input):
import re
numbers = re.findall('\d+',input)
numbers = map(int,numbers)
return max(numbers)
|
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 | 829 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_dead_code_insert
|
def get_key(dict):
list = []
_i_6 = 0
if _i_6 > _i_6:
list.append(key)
for key in dict.keys():
list.append(key)
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_for_while_loop
|
def get_key(dict):
list = []
_key_i = 0
while _key_i < len(dict.keys()):
key = dict.keys()[_key_i]
list.append(key)
_key_i += 1
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_operand_swap
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_rename_variable_cb
|
def get_key(dict):
list = []
for s in dict.keys():
list.append(s)
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_rename_variable_naive
|
def get_key(dict):
list = []
for VAR_0 in dict.keys():
list.append(VAR_0)
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_rename_variable_rn
|
def get_key(dict):
list = []
for C38 in dict.keys():
list.append(C38)
return list
| 1 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
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 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
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 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
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 | 830 |
mbpp
|
def get_key(dict):
list = []
for key in dict.keys():
list.append(key)
return list
|
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 | 830 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_dead_code_insert
|
def generate_matrix(n):
if n <= 0:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
_i_2 = 0
if _i_2 > _i_2:
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = current
current += 1
col_ed = n - 1
current = 1
while True:
if current > n * n:
break
for c in range(col_st, col_ed + 1):
matrix[row_st][c] = current
current += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = current
current += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = current
current += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = current
current += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_for_while_loop
|
def generate_matrix(n):
if n <= 0:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
col_ed = n - 1
current = 1
while True:
if current > n * n:
break
c = col_st
while c < col_ed + 1:
matrix[row_st][c] = current
current += 1
c += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = current
current += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = current
current += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = current
current += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_operand_swap
|
def generate_matrix(n):
if 0 >= n:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
col_ed = n - 1
current = 1
while True:
if current > n * n:
break
for c in range(col_st, col_ed + 1):
matrix[row_st][c] = current
current += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = current
current += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = current
current += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = current
current += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_rename_variable_cb
|
def generate_matrix(n):
if n <= 0:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
col_ed = n - 1
r2 = 1
while True:
if r2 > n * n:
break
for c in range(col_st, col_ed + 1):
matrix[row_st][c] = r2
r2 += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = r2
r2 += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = r2
r2 += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = r2
r2 += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_rename_variable_naive
|
def generate_matrix(n):
if n <= 0:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
col_ed = n - 1
VAR_0 = 1
while True:
if VAR_0 > n * n:
break
for c in range(col_st, col_ed + 1):
matrix[row_st][c] = VAR_0
VAR_0 += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = VAR_0
VAR_0 += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = VAR_0
VAR_0 += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = VAR_0
VAR_0 += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_rename_variable_rn
|
def generate_matrix(n):
if n <= 0:
return []
matrix = [row[:] for row in [[0] * n] * n]
row_st = 0
row_ed = n - 1
col_st = 0
col_ed = n - 1
BKF061h = 1
while True:
if BKF061h > n * n:
break
for c in range(col_st, col_ed + 1):
matrix[row_st][c] = BKF061h
BKF061h += 1
row_st += 1
for r in range(row_st, row_ed + 1):
matrix[r][col_ed] = BKF061h
BKF061h += 1
col_ed -= 1
for c in range(col_ed, col_st - 1, -1):
matrix[row_ed][c] = BKF061h
BKF061h += 1
row_ed -= 1
for r in range(row_ed, row_st - 1, -1):
matrix[r][col_st] = BKF061h
BKF061h += 1
col_st += 1
return matrix
| 1 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_add_sub_variable
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed-1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_sub_add_variable
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n+1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_mul_div_variable
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]/n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_lesser_greater_variable
|
def generate_matrix(n):
if n>=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_greater_lesser_variable
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current<n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
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 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
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 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
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 | 831 |
mbpp
|
def generate_matrix(n):
if n<=0:
return []
matrix=[row[:] for row in [[0]*n]*n]
row_st=0
row_ed=n-1
col_st=0
col_ed=n-1
current=1
while (True):
if current>n*n:
break
for c in range (col_st, col_ed+1):
matrix[row_st][c]=current
current+=1
row_st+=1
for r in range (row_st, row_ed+1):
matrix[r][col_ed]=current
current+=1
col_ed-=1
for c in range (col_ed, col_st-1, -1):
matrix[row_ed][c]=current
current+=1
row_ed-=1
for r in range (row_ed, row_st-1, -1):
matrix[r][col_st]=current
current+=1
col_st+=1
return matrix
|
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 | 831 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
transformation_dead_code_insert
|
def slope(x1, y1, x2, y2):
for _i_5 in range(0):
return (float)(y2 - y1) / (x2 - x1)
return (float)(y2 - y1) / (x2 - x1)
| 1 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
transformation_sub_add_variable
|
def slope(x1,y1,x2,y2):
return (float)(y2+y1)/(x2-x1)
| 0 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
transformation_div_mul_variable
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)*(x2-x1)
| 0 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
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 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
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 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
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 | 832 |
mbpp
|
def slope(x1,y1,x2,y2):
return (float)(y2-y1)/(x2-x1)
|
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 | 832 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_dead_code_insert
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
_i_1 = 0
if _i_1 > _i_1:
end = 0
end = 0
s = 0
for i in range(0, size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i + 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_for_while_loop
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
i = 0
while i < size:
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i + 1
i += 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_operand_swap
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0, size):
max_ending_here += a[i]
if max_ending_here > max_so_far:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i + 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_rename_variable_cb
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
i2 = 0
start = 0
end = 0
s = 0
for i in range(0, size):
i2 += a[i]
if max_so_far < i2:
max_so_far = i2
start = s
end = i
if i2 < 0:
i2 = 0
s = i + 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_rename_variable_naive
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
VAR_0 = 0
start = 0
end = 0
s = 0
for i in range(0, size):
VAR_0 += a[i]
if max_so_far < VAR_0:
max_so_far = VAR_0
start = s
end = i
if VAR_0 < 0:
VAR_0 = 0
s = i + 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_rename_variable_rn
|
def max_sub_array_sum(a, size):
from sys import maxsize
max_so_far = -maxsize - 1
x1179D187l0m9f1 = 0
start = 0
end = 0
s = 0
for i in range(0, size):
x1179D187l0m9f1 += a[i]
if max_so_far < x1179D187l0m9f1:
max_so_far = x1179D187l0m9f1
start = s
end = i
if x1179D187l0m9f1 < 0:
x1179D187l0m9f1 = 0
s = i + 1
return end - start + 1
| 1 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_add_sub_variable
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here -= a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
| 0 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_sub_add_variable
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = +maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
| 0 | 833 |
mbpp
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far < max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
|
transformation_lesser_greater_variable
|
def max_sub_array_sum(a,size):
from sys import maxsize
max_so_far = -maxsize - 1
max_ending_here = 0
start = 0
end = 0
s = 0
for i in range(0,size):
max_ending_here += a[i]
if max_so_far > max_ending_here:
max_so_far = max_ending_here
start = s
end = i
if max_ending_here < 0:
max_ending_here = 0
s = i+1
return (end - start + 1)
| 0 | 833 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.