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... | 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])
... | 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 | 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... | 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-... | 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-... | 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-... | 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-... | 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
... | 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 ... | 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:
... | 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:
... | 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:
... | 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:
... | 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-... | 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-... | 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-... | 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)... | 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):
... | 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)... | 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... | 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)... | 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:
... | 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)... | 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] == Fal... | 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)... | 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... | 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)... | 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:
... | 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)... | 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)... | 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)... | 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)... | 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)... | 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)... | 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)... | 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... | 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)... | 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-... | 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)... | 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)... | 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.