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.