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 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_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 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_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 | 512 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_dead_code_insert
|
def sqrt_root(num):
import math
_i_5 = 0
if _i_5 < _i_5:
return sqrt_root
sqrt_root = math.pow(num, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_for_while_loop
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_operand_swap
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_rename_variable_cb
|
def sqrt_root(n):
import math
sqrt_root = math.pow(n, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_rename_variable_naive
|
def sqrt_root(VAR_0):
import math
sqrt_root = math.pow(VAR_0, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_rename_variable_rn
|
def sqrt_root(H6v):
import math
sqrt_root = math.pow(H6v, 0.5)
return sqrt_root
| 1 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
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 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
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 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
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 | 515 |
mbpp
|
def sqrt_root(num):
import math
sqrt_root = math.pow(num, 0.5)
return sqrt_root
|
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 | 515 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_dead_code_insert
|
def get_lcm(l):
def find_lcm(num1, num2):
if num1 > num2:
num = num1
den = num2
else:
num = num2
_i_2 = 0
while _i_2 < _i_2:
rem = num % den
den = num1
rem = num % den
while rem != 0:
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2) / int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_for_while_loop
|
def get_lcm(l):
def find_lcm(num1, num2):
if num1 > num2:
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while rem != 0:
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2) / int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
i = 2
while i < len(l):
lcm = find_lcm(lcm, l[i])
i += 1
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_operand_swap
|
def get_lcm(l):
def find_lcm(num1, num2):
if num2 < num1:
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while rem != 0:
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2) / int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_rename_variable_cb
|
def get_lcm(l):
def find_lcm(num1, num2):
if num1 > num2:
num = num1
num2 = num2
else:
num = num2
num2 = num1
rem = num % num2
while rem != 0:
num = num2
num2 = rem
rem = num % num2
gcd = num2
lcm = int(int(num1 * num2) / int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_rename_variable_naive
|
def get_lcm(l):
def find_lcm(VAR_0, num2):
if VAR_0 > num2:
num = VAR_0
den = num2
else:
num = num2
den = VAR_0
rem = num % den
while rem != 0:
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(VAR_0 * num2) / int(gcd))
return lcm
VAR_0 = l[0]
num2 = l[1]
lcm = find_lcm(VAR_0, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_rename_variable_rn
|
def get_lcm(l):
def find_lcm(num1, num2):
if num1 > num2:
num = num1
ovN = num2
else:
num = num2
ovN = num1
rem = num % ovN
while rem != 0:
num = ovN
ovN = rem
rem = num % ovN
gcd = ovN
lcm = int(int(num1 * num2) / int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 1 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_mul_div_variable
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 / num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 0 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_div_mul_variable
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)*int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 0 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_greater_lesser_variable
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1<num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 0 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_exclamation_equalto_variable
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem == 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
| 0 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
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 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
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 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
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 | 517 |
mbpp
|
def get_lcm(l):
def find_lcm(num1, num2):
if(num1>num2):
num = num1
den = num2
else:
num = num2
den = num1
rem = num % den
while (rem != 0):
num = den
den = rem
rem = num % den
gcd = den
lcm = int(int(num1 * num2)/int(gcd))
return lcm
num1 = l[0]
num2 = l[1]
lcm = find_lcm(num1, num2)
for i in range(2, len(l)):
lcm = find_lcm(lcm, l[i])
return lcm
|
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 | 517 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dead_code_insert
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1)
or "String must have 1 upper case character.",
lambda str1: any(x.islower() for x in str1)
or "String must have 1 lower case character.",
lambda str1: any(x.isdigit() for x in str1) or "String must have 1 number.",
lambda str1: len(str1) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_for_while_loop
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1)
or "String must have 1 upper case character.",
lambda str1: any(x.islower() for x in str1)
or "String must have 1 lower case character.",
lambda str1: any(x.isdigit() for x in str1) or "String must have 1 number.",
lambda str1: len(str1) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_operand_swap
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1)
or "String must have 1 upper case character.",
lambda str1: any(x.islower() for x in str1)
or "String must have 1 lower case character.",
lambda str1: any(x.isdigit() for x in str1) or "String must have 1 number.",
lambda str1: len(str1) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(str1) for i in messg] if True != x]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_rename_variable_cb
|
def check_string(x2):
messg = [
lambda x2: any(x.isupper() for x in x2)
or "String must have 1 upper case character.",
lambda x2: any(x.islower() for x in x2)
or "String must have 1 lower case character.",
lambda x2: any(x.isdigit() for x in x2) or "String must have 1 number.",
lambda x2: len(x2) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(x2) for i in messg] if x != True]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_rename_variable_naive
|
def check_string(VAR_0):
messg = [
lambda VAR_0: any(x.isupper() for x in VAR_0)
or "String must have 1 upper case character.",
lambda VAR_0: any(x.islower() for x in VAR_0)
or "String must have 1 lower case character.",
lambda VAR_0: any(x.isdigit() for x in VAR_0) or "String must have 1 number.",
lambda VAR_0: len(VAR_0) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(VAR_0) for i in messg] if x != True]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_rename_variable_rn
|
def check_string(eD79):
messg = [
lambda eD79: any(x.isupper() for x in eD79)
or "String must have 1 upper case character.",
lambda eD79: any(x.islower() for x in eD79)
or "String must have 1 lower case character.",
lambda eD79: any(x.isdigit() for x in eD79) or "String must have 1 number.",
lambda eD79: len(eD79) >= 7 or "String length should be atleast 8.",
]
result = [x for x in [i(eD79) for i in messg] if x != True]
if not result:
result.append("Valid string.")
return result
| 1 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_greater_lesser_variable
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) <= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_exclamation_equalto_variable
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x == True]
if not result:
result.append('Valid string.')
return result
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_or_and_variable
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) and 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 520 |
mbpp
|
def check_string(str1):
messg = [
lambda str1: any(x.isupper() for x in str1) or 'String must have 1 upper case character.',
lambda str1: any(x.islower() for x in str1) or 'String must have 1 lower case character.',
lambda str1: any(x.isdigit() for x in str1) or 'String must have 1 number.',
lambda str1: len(str1) >= 7 or 'String length should be atleast 8.',]
result = [x for x in [i(str1) for i in messg] if x != True]
if not result:
result.append('Valid string.')
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 520 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_dead_code_insert
|
def get_pairs_count(arr, n, sum):
for _i_4 in range(0):
count = 0
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_for_while_loop
|
def get_pairs_count(arr, n, sum):
count = 0
i = 0
while i < n:
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
i += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_operand_swap
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if sum == arr[i] + arr[j]:
count += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_rename_variable_cb
|
def get_pairs_count(arr, n, sum):
count = 0
for i2 in range(0, n):
for j in range(i2 + 1, n):
if arr[i2] + arr[j] == sum:
count += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_rename_variable_naive
|
def get_pairs_count(arr, VAR_0, sum):
count = 0
for i in range(0, VAR_0):
for j in range(i + 1, VAR_0):
if arr[i] + arr[j] == sum:
count += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_rename_variable_rn
|
def get_pairs_count(IFE, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if IFE[i] + IFE[j] == sum:
count += 1
return count
| 1 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_add_sub_variable
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i - 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
| 0 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_equalto_exclamation_variable
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] != sum:
count += 1
return count
| 0 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
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 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
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 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
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 | 524 |
mbpp
|
def get_pairs_count(arr, n, sum):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if arr[i] + arr[j] == sum:
count += 1
return count
|
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 | 524 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_dead_code_insert
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
_i_7 = 0
while _i_7 > _i_7:
temp = set()
return word
else:
temp.add(word)
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_for_while_loop
|
def first_repeated_word(str1):
temp = set()
_word_i = 0
while _word_i < len(str1.split()):
word = str1.split()[_word_i]
if word in temp:
return word
else:
temp.add(word)
_word_i += 1
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_operand_swap
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word
else:
temp.add(word)
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_rename_variable_cb
|
def first_repeated_word(str1):
temp = set()
for line in str1.split():
if line in temp:
return line
else:
temp.add(line)
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_rename_variable_naive
|
def first_repeated_word(str1):
temp = set()
for VAR_0 in str1.split():
if VAR_0 in temp:
return VAR_0
else:
temp.add(VAR_0)
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_rename_variable_rn
|
def first_repeated_word(str1):
temp = set()
for f60j in str1.split():
if f60j in temp:
return f60j
else:
temp.add(f60j)
return "None"
| 1 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
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 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
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 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
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 | 534 |
mbpp
|
def first_repeated_word(str1):
temp = set()
for word in str1.split():
if word in temp:
return word;
else:
temp.add(word)
return 'None'
|
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 | 534 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dead_code_insert
|
def basesnum_coresspondingnum(bases_num, index):
_i_2 = 0
if _i_2 < _i_2:
return result
result = list(map(pow, bases_num, index))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_for_while_loop
|
def basesnum_coresspondingnum(bases_num, index):
result = list(map(pow, bases_num, index))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_operand_swap
|
def basesnum_coresspondingnum(bases_num, index):
result = list(map(pow, bases_num, index))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_rename_variable_cb
|
def basesnum_coresspondingnum(result2, index):
result = list(map(pow, result2, index))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_rename_variable_naive
|
def basesnum_coresspondingnum(VAR_0, index):
result = list(map(pow, VAR_0, index))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_rename_variable_rn
|
def basesnum_coresspondingnum(bases_num, svb44):
result = list(map(pow, bases_num, svb44))
return result
| 1 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dissimilar_code_injection_0
|
def min_cost(cost, m, n):
R = 3
C = 3
tc = [[0 for x in range(C)] for x in range(R)]
tc[0][0] = cost[0][0]
for i in range(1, m+1):
tc[i][0] = tc[i-1][0] + cost[i][0]
for j in range(1, n+1):
tc[0][j] = tc[0][j-1] + cost[0][j]
for i in range(1, m+1):
for j in range(1, n+1):
tc[i][j] = min(tc[i-1][j-1], tc[i-1][j], tc[i][j-1]) + cost[i][j]
return tc[m][n]
| 0 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dissimilar_code_injection_2
|
def is_not_prime(n):
import math
result = False
for i in range(2,int(math.sqrt(n)) + 1):
if n % i == 0:
result = True
return result
| 0 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dissimilar_code_injection_3
|
def heap_queue_largest(nums,n):
import heapq as hq
largest_nums = hq.nlargest(n, nums)
return largest_nums
| 0 | 536 |
mbpp
|
def basesnum_coresspondingnum(bases_num,index):
result = list(map(pow, bases_num, index))
return result
|
transformation_dissimilar_code_injection_4
|
def count_ways(n):
A = [0] * (n + 1)
B = [0] * (n + 1)
A[0] = 1
A[1] = 0
B[0] = 0
B[1] = 1
for i in range(2, n+1):
A[i] = A[i - 2] + 2 * B[i - 1]
B[i] = A[i - 1] + B[i - 2]
return A[n]
| 0 | 536 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_dead_code_insert
|
def find_Diff(arr, n):
for _i_9 in range(0):
continue
arr.sort()
count = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count, count)
min_count = min(min_count, count)
count = 0
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_for_while_loop
|
def find_Diff(arr, n):
arr.sort()
count = 0
max_count = 0
min_count = n
i = 0
while i < (n - 1):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count, count)
min_count = min(min_count, count)
count = 0
i += 1
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_operand_swap
|
def find_Diff(arr, n):
arr.sort()
count = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if arr[i + 1] == arr[i]:
count += 1
continue
else:
max_count = max(max_count, count)
min_count = min(min_count, count)
count = 0
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_rename_variable_cb
|
def find_Diff(arr, n):
arr.sort()
diff = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if arr[i] == arr[i + 1]:
diff += 1
continue
else:
max_count = max(max_count, diff)
min_count = min(min_count, diff)
diff = 0
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_rename_variable_naive
|
def find_Diff(arr, n):
arr.sort()
VAR_0 = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if arr[i] == arr[i + 1]:
VAR_0 += 1
continue
else:
max_count = max(max_count, VAR_0)
min_count = min(min_count, VAR_0)
VAR_0 = 0
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_rename_variable_rn
|
def find_Diff(arr, n):
arr.sort()
P7uM5 = 0
max_count = 0
min_count = n
for i in range(0, (n - 1)):
if arr[i] == arr[i + 1]:
P7uM5 += 1
continue
else:
max_count = max(max_count, P7uM5)
min_count = min(min_count, P7uM5)
P7uM5 = 0
return max_count - min_count
| 1 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_add_sub_variable
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i - 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
| 0 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_sub_add_variable
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n+1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
| 0 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_equalto_exclamation_variable
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] != arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
| 0 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
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 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
transformation_dissimilar_code_injection_1
|
def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res)
| 0 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
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 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
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 | 537 |
mbpp
|
def find_Diff(arr,n):
arr.sort()
count = 0; max_count = 0; min_count = n
for i in range(0,(n-1)):
if arr[i] == arr[i + 1]:
count += 1
continue
else:
max_count = max(max_count,count)
min_count = min(min_count,count)
count = 0
return max_count - min_count
|
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 | 537 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_dead_code_insert
|
def count_digits(num1, num2):
number = num1 + num2
_i_6 = 0
while _i_6 < _i_6:
number = number // 10
count = 0
while number > 0:
number = number // 10
count = count + 1
return count
| 1 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_for_while_loop
|
def count_digits(num1, num2):
number = num1 + num2
count = 0
while number > 0:
number = number // 10
count = count + 1
return count
| 1 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_operand_swap
|
def count_digits(num1, num2):
number = num1 + num2
count = 0
while 0 < number:
number = number // 10
count = count + 1
return count
| 1 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_rename_variable_naive
|
def count_digits(num1, num2):
VAR_0 = num1 + num2
count = 0
while VAR_0 > 0:
VAR_0 = VAR_0 // 10
count = count + 1
return count
| 1 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_rename_variable_rn
|
def count_digits(num1, num2):
number = num1 + num2
ZjYP6 = 0
while number > 0:
number = number // 10
ZjYP6 = ZjYP6 + 1
return ZjYP6
| 1 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_add_sub_variable
|
def count_digits(num1,num2):
number=num1-num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
| 0 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_div_mul_variable
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number */ 10
count = count + 1
return count
| 0 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
transformation_greater_lesser_variable
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number < 0):
number = number // 10
count = count + 1
return count
| 0 | 540 |
mbpp
|
def count_digits(num1,num2):
number=num1+num2
count = 0
while(number > 0):
number = number // 10
count = count + 1
return count
|
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 | 540 |
mbpp
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.