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 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 | 561 |
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 | 561 |
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 | 561 |
mbpp
|
def split(word):
return [char for char in word]
|
transformation_dead_code_insert
|
def split(word):
while False:
return [char for char in word]
return [char for char in word]
| 1 | 562 |
mbpp
|
def split(word):
return [char for char in word]
|
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 | 562 |
mbpp
|
def split(word):
return [char for char in word]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 562 |
mbpp
|
def split(word):
return [char for char in word]
|
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 | 562 |
mbpp
|
def split(word):
return [char for char in word]
|
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 | 562 |
mbpp
|
def split(word):
return [char for char in word]
|
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 | 562 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_dead_code_insert
|
def sum_digits(n):
if n == 0:
_i_7 = 0
if _i_7 > _i_7:
return n % 10 + sum_digits(int(n / 10))
return 0
else:
return n % 10 + sum_digits(int(n / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_for_while_loop
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_operand_swap
|
def sum_digits(n):
if 0 == n:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_rename_variable_cb
|
def sum_digits(i):
if i == 0:
return 0
else:
return i % 10 + sum_digits(int(i / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_rename_variable_naive
|
def sum_digits(VAR_0):
if VAR_0 == 0:
return 0
else:
return VAR_0 % 10 + sum_digits(int(VAR_0 / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_rename_variable_rn
|
def sum_digits(Z):
if Z == 0:
return 0
else:
return Z % 10 + sum_digits(int(Z / 10))
| 1 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_add_sub_variable
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 - sum_digits(int(n / 10))
| 0 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_div_mul_variable
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n * 10))
| 0 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_equalto_exclamation_variable
|
def sum_digits(n):
if n != 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
| 0 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
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 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
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 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
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 | 563 |
mbpp
|
def sum_digits(n):
if n == 0:
return 0
else:
return n % 10 + sum_digits(int(n / 10))
|
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 | 563 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_dead_code_insert
|
def issort_list(list1):
while False:
return result
result = all(list1[i] <= list1[i + 1] for i in range(len(list1) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_for_while_loop
|
def issort_list(list1):
result = all(list1[i] <= list1[i + 1] for i in range(len(list1) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_operand_swap
|
def issort_list(list1):
result = all(list1[i + 1] >= list1[i] for i in range(len(list1) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_rename_variable_cb
|
def issort_list(l):
result = all(l[i] <= l[i + 1] for i in range(len(l) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_rename_variable_naive
|
def issort_list(VAR_0):
result = all(VAR_0[i] <= VAR_0[i + 1] for i in range(len(VAR_0) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_rename_variable_rn
|
def issort_list(b5N09):
result = all(b5N09[i] <= b5N09[i + 1] for i in range(len(b5N09) - 1))
return result
| 1 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_add_sub_variable
|
def issort_list(list1):
result = all(list1[i] <= list1[i-1] for i in range(len(list1)-1))
return result
| 0 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_sub_add_variable
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)+1))
return result
| 0 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
return result
|
transformation_lesser_greater_variable
|
def issort_list(list1):
result = all(list1[i] >= list1[i+1] for i in range(len(list1)-1))
return result
| 0 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
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 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
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 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
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 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
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 | 564 |
mbpp
|
def issort_list(list1):
result = all(list1[i] <= list1[i+1] for i in range(len(list1)-1))
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 | 564 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_dead_code_insert
|
def empty_list(length):
_i_1 = 0
while _i_1 < _i_1:
empty_list = [{} for _ in range(length)]
empty_list = [{} for _ in range(length)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_for_while_loop
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_operand_swap
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_rename_variable_cb
|
def empty_list(lines):
empty_list = [{} for _ in range(lines)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_rename_variable_naive
|
def empty_list(VAR_0):
empty_list = [{} for _ in range(VAR_0)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_rename_variable_rn
|
def empty_list(cJKp5S):
empty_list = [{} for _ in range(cJKp5S)]
return empty_list
| 1 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_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 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_list
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_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 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_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 | 565 |
mbpp
|
def empty_list(length):
empty_list = [{} for _ in range(length)]
return empty_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 | 565 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_dead_code_insert
|
def sort_sublists(list1):
_i_4 = 0
while _i_4 < _i_4:
result = list(map(sorted, list1))
result = list(map(sorted, list1))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_for_while_loop
|
def sort_sublists(list1):
result = list(map(sorted, list1))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_operand_swap
|
def sort_sublists(list1):
result = list(map(sorted, list1))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_rename_variable_cb
|
def sort_sublists(result2):
result = list(map(sorted, result2))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_rename_variable_naive
|
def sort_sublists(VAR_0):
result = list(map(sorted, VAR_0))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,list1))
return result
|
transformation_rename_variable_rn
|
def sort_sublists(EQj79):
result = list(map(sorted, EQj79))
return result
| 1 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,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 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,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 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,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 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,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 | 566 |
mbpp
|
def sort_sublists(list1):
result = list(map(sorted,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 | 566 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_dead_code_insert
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i) == 1]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_for_while_loop
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i) == 1]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_operand_swap
|
def two_unique_nums(nums):
return [i for i in nums if 1 == nums.count(i)]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_rename_variable_cb
|
def two_unique_nums(nums):
return [n for n in nums if nums.count(n) == 1]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_rename_variable_naive
|
def two_unique_nums(VAR_0):
return [i for i in VAR_0 if VAR_0.count(i) == 1]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_rename_variable_rn
|
def two_unique_nums(nums):
return [g for g in nums if nums.count(g) == 1]
| 1 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_equalto_exclamation_variable
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)!=1]
| 0 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
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 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
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 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
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 | 569 |
mbpp
|
def two_unique_nums(nums):
return [i for i in nums if nums.count(i)==1]
|
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 | 569 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_dead_code_insert
|
def surfacearea_cylinder(r, h):
for _i_7 in range(0):
return surfacearea
surfacearea = (2 * 3.1415 * r * r) + (2 * 3.1415 * r * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_for_while_loop
|
def surfacearea_cylinder(r, h):
surfacearea = (2 * 3.1415 * r * r) + (2 * 3.1415 * r * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_operand_swap
|
def surfacearea_cylinder(r, h):
surfacearea = (2 * 3.1415 * r * r) + (2 * 3.1415 * r * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_rename_variable_cb
|
def surfacearea_cylinder(w, h):
surfacearea = (2 * 3.1415 * w * w) + (2 * 3.1415 * w * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_rename_variable_naive
|
def surfacearea_cylinder(VAR_0, h):
surfacearea = (2 * 3.1415 * VAR_0 * VAR_0) + (2 * 3.1415 * VAR_0 * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_rename_variable_rn
|
def surfacearea_cylinder(b, h):
surfacearea = (2 * 3.1415 * b * b) + (2 * 3.1415 * b * h)
return surfacearea
| 1 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_add_sub_variable
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) -(2*3.1415*r*h))
return surfacearea
| 0 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_mul_div_variable
|
def surfacearea_cylinder(r,h):
surfacearea=((2/3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
| 0 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
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 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
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 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
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 | 571 |
mbpp
|
def surfacearea_cylinder(r,h):
surfacearea=((2*3.1415*r*r) +(2*3.1415*r*h))
return surfacearea
|
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 | 571 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_dead_code_insert
|
def is_Sub_Array(A, B, n, m):
i = 0
j = 0
while i < n and j < m:
if A[i] == B[j]:
if False:
i = 0
i += 1
j += 1
if j == m:
return True
else:
i = i - j + 1
j = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_for_while_loop
|
def is_Sub_Array(A, B, n, m):
i = 0
j = 0
while i < n and j < m:
if A[i] == B[j]:
i += 1
j += 1
if j == m:
return True
else:
i = i - j + 1
j = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_operand_swap
|
def is_Sub_Array(A, B, n, m):
i = 0
j = 0
while n > i and j < m:
if A[i] == B[j]:
i += 1
j += 1
if j == m:
return True
else:
i = i - j + 1
j = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_rename_variable_cb
|
def is_Sub_Array(A, B, n, m):
i = 0
i2 = 0
while i < n and i2 < m:
if A[i] == B[i2]:
i += 1
i2 += 1
if i2 == m:
return True
else:
i = i - i2 + 1
i2 = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_rename_variable_naive
|
def is_Sub_Array(A, B, n, m):
i = 0
VAR_0 = 0
while i < n and VAR_0 < m:
if A[i] == B[VAR_0]:
i += 1
VAR_0 += 1
if VAR_0 == m:
return True
else:
i = i - VAR_0 + 1
VAR_0 = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_rename_variable_rn
|
def is_Sub_Array(A, B, n, m):
i = 0
y = 0
while i < n and y < m:
if A[i] == B[y]:
i += 1
y += 1
if y == m:
return True
else:
i = i - y + 1
y = 0
return False
| 1 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_add_sub_variable
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i -= 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
| 0 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_sub_add_variable
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i + j + 1;
j = 0;
return False;
| 0 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_lesser_greater_variable
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i > n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
| 0 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_equalto_exclamation_variable
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] != B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
| 0 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
|
transformation_and_or_variable
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n or j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
return False;
| 0 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
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 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
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 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
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 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
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 | 573 |
mbpp
|
def is_Sub_Array(A,B,n,m):
i = 0; j = 0;
while (i < n and j < m):
if (A[i] == B[j]):
i += 1;
j += 1;
if (j == m):
return True;
else:
i = i - j + 1;
j = 0;
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 | 573 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.