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 combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_dead_code_insert
|
def combinations_colors(l, n):
_i_8 = 0
while _i_8 > _i_8:
from itertools import combinations_with_replacement
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l, n))
| 1 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_for_while_loop
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l, n))
| 1 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_operand_swap
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l, n))
| 1 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_rename_variable_naive
|
def combinations_colors(VAR_0, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(VAR_0, n))
| 1 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_rename_variable_rn
|
def combinations_colors(D, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(D, n))
| 1 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
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 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
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 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
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 | 252 |
mbpp
|
def combinations_colors(l, n):
from itertools import combinations_with_replacement
return list(combinations_with_replacement(l,n))
|
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 | 252 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_dead_code_insert
|
def count_Primes_nums(n):
_i_5 = 0
while _i_5 < _i_5:
continue
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2, num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_for_while_loop
|
def count_Primes_nums(n):
ctr = 0
num = 0
while num < n:
if num <= 1:
continue
for i in range(2, num):
if (num % i) == 0:
break
else:
ctr += 1
num += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_operand_swap
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if 1 >= num:
continue
for i in range(2, num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_rename_variable_cb
|
def count_Primes_nums(n):
ctr = 0
for i2 in range(n):
if i2 <= 1:
continue
for i in range(2, i2):
if (i2 % i) == 0:
break
else:
ctr += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_rename_variable_naive
|
def count_Primes_nums(n):
ctr = 0
for VAR_0 in range(n):
if VAR_0 <= 1:
continue
for i in range(2, VAR_0):
if (VAR_0 % i) == 0:
break
else:
ctr += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_rename_variable_rn
|
def count_Primes_nums(n):
ctr = 0
for N41 in range(n):
if N41 <= 1:
continue
for i in range(2, N41):
if (N41 % i) == 0:
break
else:
ctr += 1
return ctr
| 1 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_add_sub_variable
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr -= 1
return ctr
| 0 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_lesser_greater_variable
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num >= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
| 0 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_equalto_exclamation_variable
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) != 0:
break
else:
ctr += 1
return ctr
| 0 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
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 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
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 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
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 | 253 |
mbpp
|
def count_Primes_nums(n):
ctr = 0
for num in range(n):
if num <= 1:
continue
for i in range(2,num):
if (num % i) == 0:
break
else:
ctr += 1
return ctr
|
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 | 253 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_dead_code_insert
|
def count_odd(array_nums):
for _i_2 in range(0):
return count_odd
count_odd = len(list(filter(lambda x: (x % 2 != 0), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_for_while_loop
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x % 2 != 0), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_operand_swap
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (0 != x % 2), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_rename_variable_cb
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda i: (i % 2 != 0), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_rename_variable_naive
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda VAR_0: (VAR_0 % 2 != 0), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_rename_variable_rn
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x2: (x2 % 2 != 0), array_nums)))
return count_odd
| 1 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_exclamation_equalto_variable
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 == 0) , array_nums)))
return count_odd
| 0 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
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 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
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 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
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 | 255 |
mbpp
|
def count_odd(array_nums):
count_odd = len(list(filter(lambda x: (x%2 != 0) , array_nums)))
return count_odd
|
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 | 255 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_dead_code_insert
|
def division_elements(test_tup1, test_tup2):
for _i_6 in range(0):
return res
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_for_while_loop
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_operand_swap
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_cb
|
def division_elements(test, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_naive
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // VAR_0 for ele1, VAR_0 in zip(test_tup1, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_rename_variable_rn
|
def division_elements(T4x741632, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(T4x741632, test_tup2))
return res
| 1 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_div_mul_variable
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 */ ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
| 0 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
return (res)
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
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 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
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 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
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 | 258 |
mbpp
|
def division_elements(test_tup1, test_tup2):
res = tuple(ele1 // ele2 for ele1, ele2 in zip(test_tup1, test_tup2))
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 | 258 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_dead_code_insert
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_for_while_loop
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_operand_swap
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_rename_variable_cb
|
def list_split(S, N):
return [S[i::N] for i in range(N)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_rename_variable_naive
|
def list_split(S, VAR_0):
return [S[i::VAR_0] for i in range(VAR_0)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_rename_variable_rn
|
def list_split(S, V340):
return [S[i::V340] for i in range(V340)]
| 1 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
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 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
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 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
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 | 262 |
mbpp
|
def list_split(S, step):
return [S[i::step] for i in range(step)]
|
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 | 262 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_dead_code_insert
|
def lateralsurface_cube(l):
_i_0 = 0
if _i_0 > _i_0:
return LSA
LSA = 4 * (l * l)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_for_while_loop
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_operand_swap
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_rename_variable_cb
|
def lateralsurface_cube(a):
LSA = 4 * (a * a)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_rename_variable_naive
|
def lateralsurface_cube(VAR_0):
LSA = 4 * (VAR_0 * VAR_0)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_rename_variable_rn
|
def lateralsurface_cube(Z):
LSA = 4 * (Z * Z)
return LSA
| 1 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_mul_div_variable
|
def lateralsurface_cube(l):
LSA = 4 / (l * l)
return LSA
| 0 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
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 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
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 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
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 | 263 |
mbpp
|
def lateralsurface_cube(l):
LSA = 4 * (l * l)
return LSA
|
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 | 263 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_dead_code_insert
|
def sum_even_and_even_index(arr, n):
for _i_7 in range(0):
return sum
i = 0
sum = 0
for i in range(0, n, 2):
if arr[i] % 2 == 0:
sum += arr[i]
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_for_while_loop
|
def sum_even_and_even_index(arr, n):
i = 0
sum = 0
i = 0
while i < n:
if arr[i] % 2 == 0:
sum += arr[i]
i += 2
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_operand_swap
|
def sum_even_and_even_index(arr, n):
i = 0
sum = 0
for i in range(0, n, 2):
if 0 == arr[i] % 2:
sum += arr[i]
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_rename_variable_cb
|
def sum_even_and_even_index(arr, n):
i2 = 0
sum = 0
for i2 in range(0, n, 2):
if arr[i2] % 2 == 0:
sum += arr[i2]
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_rename_variable_naive
|
def sum_even_and_even_index(arr, n):
VAR_0 = 0
sum = 0
for VAR_0 in range(0, n, 2):
if arr[VAR_0] % 2 == 0:
sum += arr[VAR_0]
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_rename_variable_rn
|
def sum_even_and_even_index(arr, n):
n2 = 0
sum = 0
for n2 in range(0, n, 2):
if arr[n2] % 2 == 0:
sum += arr[n2]
return sum
| 1 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_add_sub_variable
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum -= arr[i]
return sum
| 0 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_equalto_exclamation_variable
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 != 0) :
sum += arr[i]
return sum
| 0 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
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 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
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 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
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 | 267 |
mbpp
|
def sum_even_and_even_index(arr,n):
i = 0
sum = 0
for i in range(0,n,2):
if (arr[i] % 2 == 0) :
sum += arr[i]
return sum
|
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 | 267 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_dead_code_insert
|
def even_Power_Sum(n):
for _i_3 in range(0):
j = 2 * i
sum = 0
for i in range(1, n + 1):
j = 2 * i
sum = sum + (j * j * j * j * j)
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_for_while_loop
|
def even_Power_Sum(n):
sum = 0
i = 1
while i < n + 1:
j = 2 * i
sum = sum + (j * j * j * j * j)
i += 1
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_operand_swap
|
def even_Power_Sum(n):
sum = 0
for i in range(1, n + 1):
j = 2 * i
sum = sum + (j * j * j * j * j)
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_rename_variable_cb
|
def even_Power_Sum(n):
sum = 0
for i in range(1, n + 1):
n2 = 2 * i
sum = sum + (n2 * n2 * n2 * n2 * n2)
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_rename_variable_naive
|
def even_Power_Sum(n):
sum = 0
for i in range(1, n + 1):
VAR_0 = 2 * i
sum = sum + (VAR_0 * VAR_0 * VAR_0 * VAR_0 * VAR_0)
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_rename_variable_rn
|
def even_Power_Sum(n):
sum = 0
for i in range(1, n + 1):
i2 = 2 * i
sum = sum + (i2 * i2 * i2 * i2 * i2)
return sum
| 1 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_add_sub_variable
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n-1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
| 0 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_mul_div_variable
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2/i;
sum = sum + (j*j*j*j*j);
return sum;
| 0 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
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 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
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 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
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 | 268 |
mbpp
|
def even_Power_Sum(n):
sum = 0;
for i in range(1,n+1):
j = 2*i;
sum = sum + (j*j*j*j*j);
return sum;
|
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 | 268 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_dead_code_insert
|
def rear_extract(test_list):
_i_9 = 0
if _i_9 < _i_9:
res = [lis[-1] for lis in test_list]
res = [lis[-1] for lis in test_list]
return res
| 1 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_for_while_loop
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return res
| 1 | 269 |
mbpp
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return (res)
|
transformation_operand_swap
|
def rear_extract(test_list):
res = [lis[-1] for lis in test_list]
return res
| 1 | 269 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.