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 permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_operand_swap
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)] for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if 0 == j:
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (j * P[i - 1][j - 1])
if j < k:
P[i][j + 1] = 0
return P[n][k]
| 1 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_rename_variable_cb
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)] for j2 in range(n + 1)]
for i in range(n + 1):
for j2 in range(min(i, k) + 1):
if j2 == 0:
P[i][j2] = 1
else:
P[i][j2] = P[i - 1][j2] + (j2 * P[i - 1][j2 - 1])
if j2 < k:
P[i][j2 + 1] = 0
return P[n][k]
| 1 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_rename_variable_naive
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)] for VAR_0 in range(n + 1)]
for i in range(n + 1):
for VAR_0 in range(min(i, k) + 1):
if VAR_0 == 0:
P[i][VAR_0] = 1
else:
P[i][VAR_0] = P[i - 1][VAR_0] + (VAR_0 * P[i - 1][VAR_0 - 1])
if VAR_0 < k:
P[i][VAR_0 + 1] = 0
return P[n][k]
| 1 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_rename_variable_rn
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)] for Q in range(n + 1)]
for i in range(n + 1):
for Q in range(min(i, k) + 1):
if Q == 0:
P[i][Q] = 1
else:
P[i][Q] = P[i - 1][Q] + (Q * P[i - 1][Q - 1])
if Q < k:
P[i][Q + 1] = 0
return P[n][k]
| 1 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_add_sub_variable
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k - 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_sub_add_variable
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i + 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_mul_div_variable
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j / P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_lesser_greater_variable
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j > k):
P[i][j + 1] = 0
return P[n][k]
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_equalto_exclamation_variable
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j != 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
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 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
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 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
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 | 503 |
mbpp
|
def permutation_coefficient(n, k):
P = [[0 for i in range(k + 1)]
for j in range(n + 1)]
for i in range(n + 1):
for j in range(min(i, k) + 1):
if (j == 0):
P[i][j] = 1
else:
P[i][j] = P[i - 1][j] + (
j * P[i - 1][j - 1])
if (j < k):
P[i][j + 1] = 0
return P[n][k]
|
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 | 503 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_dead_code_insert
|
def remove_words(list1, removewords):
for word in list(list1):
for _i_3 in range(0):
list1.remove(word)
if word in removewords:
list1.remove(word)
return list1
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_for_while_loop
|
def remove_words(list1, removewords):
_word_i = 0
while _word_i < len(list(list1)):
word = list(list1)[_word_i]
if word in removewords:
list1.remove(word)
_word_i += 1
return list1
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_operand_swap
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_rename_variable_cb
|
def remove_words(lines, removewords):
for word in list(lines):
if word in removewords:
lines.remove(word)
return lines
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_rename_variable_naive
|
def remove_words(VAR_0, removewords):
for word in list(VAR_0):
if word in removewords:
VAR_0.remove(word)
return VAR_0
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_rename_variable_rn
|
def remove_words(e1l39, removewords):
for word in list(e1l39):
if word in removewords:
e1l39.remove(word)
return e1l39
| 1 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
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 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
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 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
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 | 504 |
mbpp
|
def remove_words(list1, removewords):
for word in list(list1):
if word in removewords:
list1.remove(word)
return list1
|
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 | 504 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_dead_code_insert
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
_i_5 = 0
if _i_5 < _i_5:
l1 = [e for e in l1 if e in common_elements]
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_for_while_loop
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_operand_swap
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l2 == l1
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_rename_variable_cb
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [l for l in l1 if l in common_elements]
l2 = [l for l in l2 if l in common_elements]
return l1 == l2
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_rename_variable_naive
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [VAR_0 for VAR_0 in l1 if VAR_0 in common_elements]
l2 = [VAR_0 for VAR_0 in l2 if VAR_0 in common_elements]
return l1 == l2
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_rename_variable_rn
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [V for V in l1 if V in common_elements]
l2 = [V for V in l2 if V in common_elements]
return l1 == l2
| 1 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_equalto_exclamation_variable
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 != l2
| 0 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
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 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
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 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
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 | 505 |
mbpp
|
def same_order(l1, l2):
common_elements = set(l1) & set(l2)
l1 = [e for e in l1 if e in common_elements]
l2 = [e for e in l2 if e in common_elements]
return l1 == l2
|
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 | 505 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_dead_code_insert
|
def find_Min_Sum(num):
sum = 0
i = 2
while i * i <= num:
while num % i == 0:
_i_4 = 0
while _i_4 > _i_4:
sum += num
sum += i
num /= i
i += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_for_while_loop
|
def find_Min_Sum(num):
sum = 0
i = 2
while i * i <= num:
while num % i == 0:
sum += i
num /= i
i += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_operand_swap
|
def find_Min_Sum(num):
sum = 0
i = 2
while num >= i * i:
while num % i == 0:
sum += i
num /= i
i += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_rename_variable_cb
|
def find_Min_Sum(num):
sum = 0
num2 = 2
while num2 * num2 <= num:
while num % num2 == 0:
sum += num2
num /= num2
num2 += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_rename_variable_naive
|
def find_Min_Sum(num):
sum = 0
VAR_0 = 2
while VAR_0 * VAR_0 <= num:
while num % VAR_0 == 0:
sum += VAR_0
num /= VAR_0
VAR_0 += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_rename_variable_rn
|
def find_Min_Sum(num):
sum = 0
d = 2
while d * d <= num:
while num % d == 0:
sum += d
num /= d
d += 1
sum += num
return sum
| 1 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_add_sub_variable
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum -= i
num /= i
i += 1
sum += num
return sum
| 0 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_mul_div_variable
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i / i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
| 0 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_div_mul_variable
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num *= i
i += 1
sum += num
return sum
| 0 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_lesser_greater_variable
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i >= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
| 0 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
return sum
|
transformation_equalto_exclamation_variable
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i != 0):
sum += i
num /= i
i += 1
sum += num
return sum
| 0 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
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 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
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 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
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 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
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 | 508 |
mbpp
|
def find_Min_Sum(num):
sum = 0
i = 2
while(i * i <= num):
while(num % i == 0):
sum += i
num /= i
i += 1
sum += num
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 | 508 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_dead_code_insert
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
_i_7 = 0
while _i_7 < _i_7:
yield tup
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return res
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_for_while_loop
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
_ele_i = 0
while _ele_i < len(flatten(test_tuple)):
ele = flatten(test_tuple)[_ele_i]
if ele not in res:
res[ele] = 0
res[ele] += 1
_ele_i += 1
return res
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_operand_swap
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return res
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_rename_variable_cb
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
test = {}
for ele in flatten(test_tuple):
if ele not in test:
test[ele] = 0
test[ele] += 1
return test
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_rename_variable_naive
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
VAR_0 = {}
for ele in flatten(test_tuple):
if ele not in VAR_0:
VAR_0[ele] = 0
VAR_0[ele] += 1
return VAR_0
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_rename_variable_rn
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
ES4 = {}
for ele in flatten(test_tuple):
if ele not in ES4:
ES4[ele] = 0
ES4[ele] += 1
return ES4
| 1 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
return (res)
|
transformation_add_sub_variable
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] -= 1
return (res)
| 0 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
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 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
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 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
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 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
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 | 509 |
mbpp
|
def count_element_freq(test_tuple):
def flatten(test_tuple):
for tup in test_tuple:
if isinstance(tup, tuple):
yield from flatten(tup)
else:
yield tup
res = {}
for ele in flatten(test_tuple):
if ele not in res:
res[ele] = 0
res[ele] += 1
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 | 509 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_dead_code_insert
|
def add_str(test_tup, K):
_i_5 = 0
if _i_5 > _i_5:
res = [ele for sub in test_tup for ele in (sub, K)]
res = [ele for sub in test_tup for ele in (sub, K)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_for_while_loop
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_operand_swap
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_rename_variable_cb
|
def add_str(subs, K):
res = [ele for sub in subs for ele in (sub, K)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_rename_variable_naive
|
def add_str(test_tup, VAR_0):
res = [ele for sub in test_tup for ele in (sub, VAR_0)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
return (res)
|
transformation_rename_variable_rn
|
def add_str(test_tup, K):
res = [ele for O84 in test_tup for ele in (O84, K)]
return res
| 1 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
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 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
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 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
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 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
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 | 510 |
mbpp
|
def add_str(test_tup, K):
res = [ele for sub in test_tup for ele in (sub, K)]
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 | 510 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_dead_code_insert
|
def sum_elements(test_tup):
for _i_8 in range(0):
res = sum(list(test_tup))
res = sum(list(test_tup))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_for_while_loop
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_operand_swap
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_rename_variable_cb
|
def sum_elements(elements):
res = sum(list(elements))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_rename_variable_naive
|
def sum_elements(VAR_0):
res = sum(list(VAR_0))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
return (res)
|
transformation_rename_variable_rn
|
def sum_elements(u4y609uL):
res = sum(list(u4y609uL))
return res
| 1 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
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 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
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 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
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 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
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 | 511 |
mbpp
|
def sum_elements(test_tup):
res = sum(list(test_tup))
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 | 511 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_dead_code_insert
|
def modular_sum(arr, n, m):
_i_9 = 0
while _i_9 < _i_9:
for j in range(m):
if DP[j] == True:
if DP[(j + arr[i]) % m] == False:
temp[(j + arr[i]) % m] = True
if n > m:
return True
DP = [False for i in range(m)]
for i in range(n):
if DP[0]:
return True
temp = [False for i in range(m)]
for j in range(m):
if DP[j] == True:
if DP[(j + arr[i]) % m] == False:
temp[(j + arr[i]) % m] = True
for j in range(m):
if temp[j]:
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_for_while_loop
|
def modular_sum(arr, n, m):
if n > m:
return True
DP = [False for i in range(m)]
i = 0
while i < n:
if DP[0]:
return True
temp = [False for i in range(m)]
for j in range(m):
if DP[j] == True:
if DP[(j + arr[i]) % m] == False:
temp[(j + arr[i]) % m] = True
for j in range(m):
if temp[j]:
DP[j] = True
DP[arr[i] % m] = True
i += 1
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_operand_swap
|
def modular_sum(arr, n, m):
if m < n:
return True
DP = [False for i in range(m)]
for i in range(n):
if DP[0]:
return True
temp = [False for i in range(m)]
for j in range(m):
if DP[j] == True:
if DP[(j + arr[i]) % m] == False:
temp[(j + arr[i]) % m] = True
for j in range(m):
if temp[j]:
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_rename_variable_cb
|
def modular_sum(arr, n, n2):
if n > n2:
return True
DP = [False for i in range(n2)]
for i in range(n):
if DP[0]:
return True
temp = [False for i in range(n2)]
for j in range(n2):
if DP[j] == True:
if DP[(j + arr[i]) % n2] == False:
temp[(j + arr[i]) % n2] = True
for j in range(n2):
if temp[j]:
DP[j] = True
DP[arr[i] % n2] = True
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_rename_variable_naive
|
def modular_sum(arr, n, VAR_0):
if n > VAR_0:
return True
DP = [False for i in range(VAR_0)]
for i in range(n):
if DP[0]:
return True
temp = [False for i in range(VAR_0)]
for j in range(VAR_0):
if DP[j] == True:
if DP[(j + arr[i]) % VAR_0] == False:
temp[(j + arr[i]) % VAR_0] = True
for j in range(VAR_0):
if temp[j]:
DP[j] = True
DP[arr[i] % VAR_0] = True
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_rename_variable_rn
|
def modular_sum(arr, n, y):
if n > y:
return True
DP = [False for i in range(y)]
for i in range(n):
if DP[0]:
return True
temp = [False for i in range(y)]
for j in range(y):
if DP[j] == True:
if DP[(j + arr[i]) % y] == False:
temp[(j + arr[i]) % y] = True
for j in range(y):
if temp[j]:
DP[j] = True
DP[arr[i] % y] = True
return DP[0]
| 1 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_add_sub_variable
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j - arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 0 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_greater_lesser_variable
|
def modular_sum(arr, n, m):
if (n < m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 0 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_equalto_exclamation_variable
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] != True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 0 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_true_false_variable
|
def modular_sum(arr, n, m):
if (n > m):
return False
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
| 0 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
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 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 512 |
mbpp
|
def modular_sum(arr, n, m):
if (n > m):
return True
DP = [False for i in range(m)]
for i in range(n):
if (DP[0]):
return True
temp = [False for i in range(m)]
for j in range(m):
if (DP[j] == True):
if (DP[(j + arr[i]) % m] == False):
temp[(j + arr[i]) % m] = True
for j in range(m):
if (temp[j]):
DP[j] = True
DP[arr[i] % m] = True
return DP[0]
|
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 | 512 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.