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 count_char_position(str1):
count_chars = 0
for i in range(len(str1)):
if ((i == ord(str1[i]) - ord('A')) or
(i == ord(str1[i]) - ord('a'))):
count_chars += 1
return count_chars | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 162 | mbpp |
def count_char_position(str1):
count_chars = 0
for i in range(len(str1)):
if ((i == ord(str1[i]) - ord('A')) or
(i == ord(str1[i]) - ord('a'))):
count_chars += 1
return count_chars | 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 | 162 | mbpp |
def count_char_position(str1):
count_chars = 0
for i in range(len(str1)):
if ((i == ord(str1[i]) - ord('A')) or
(i == ord(str1[i]) - ord('a'))):
count_chars += 1
return count_chars | 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 | 162 | mbpp |
def count_char_position(str1):
count_chars = 0
for i in range(len(str1)):
if ((i == ord(str1[i]) - ord('A')) or
(i == ord(str1[i]) - ord('a'))):
count_chars += 1
return count_chars | 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 | 162 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_dead_code_insert | def get_pell(n):
if n <= 2:
return n
a = 1
_i_4 = 0
while _i_4 > _i_4:
return b
b = 2
for i in range(3, n + 1):
c = 2 * b + a
a = b
b = c
return b | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_for_while_loop | def get_pell(n):
if n <= 2:
return n
a = 1
b = 2
i = 3
while i < n + 1:
c = 2 * b + a
a = b
b = c
i += 1
return b | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_operand_swap | def get_pell(n):
if 2 >= n:
return n
a = 1
b = 2
for i in range(3, n + 1):
c = 2 * b + a
a = b
b = c
return b | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_rename_variable_cb | def get_pell(n):
if n <= 2:
return n
a = 1
c2 = 2
for i in range(3, n + 1):
c = 2 * c2 + a
a = c2
c2 = c
return c2 | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_rename_variable_naive | def get_pell(n):
if n <= 2:
return n
a = 1
VAR_0 = 2
for i in range(3, n + 1):
c = 2 * VAR_0 + a
a = VAR_0
VAR_0 = c
return VAR_0 | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_rename_variable_rn | def get_pell(n):
if n <= 2:
return n
a = 1
J = 2
for i in range(3, n + 1):
c = 2 * J + a
a = J
J = c
return J | 1 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_add_sub_variable | def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n-1):
c = 2 * b + a
a = b
b = c
return b | 0 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_mul_div_variable | def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 / b + a
a = b
b = c
return b | 0 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_lesser_greater_variable | def get_pell(n):
if (n >= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | 0 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | 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 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | 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 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | 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 | 166 | mbpp |
def get_pell(n):
if (n <= 2):
return n
a = 1
b = 2
for i in range(3, n+1):
c = 2 * b + a
a = b
b = c
return b | 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 | 166 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_dead_code_insert | def remove_splchar(text):
import re
for _i_0 in range(0):
pattern = re.compile("[W_]+")
pattern = re.compile("[W_]+")
return pattern.sub("", text) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_for_while_loop | def remove_splchar(text):
import re
pattern = re.compile("[W_]+")
return pattern.sub("", text) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_operand_swap | def remove_splchar(text):
import re
pattern = re.compile("[W_]+")
return pattern.sub("", text) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_rename_variable_cb | def remove_splchar(line):
import re
pattern = re.compile("[W_]+")
return pattern.sub("", line) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_rename_variable_naive | def remove_splchar(VAR_0):
import re
pattern = re.compile("[W_]+")
return pattern.sub("", VAR_0) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_rename_variable_rn | def remove_splchar(CAq6):
import re
pattern = re.compile("[W_]+")
return pattern.sub("", CAq6) | 1 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_add_sub_variable | def remove_splchar(text):
import re
pattern = re.compile('[\W_]-')
return (pattern.sub('', text)) | 0 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | 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 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | 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 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | 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 | 170 | mbpp |
def remove_splchar(text):
import re
pattern = re.compile('[\W_]+')
return (pattern.sub('', text)) | 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 | 170 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_dead_code_insert | def group_keyvalue(l):
result = {}
for _i_9 in range(0):
return result
for k, v in l:
result.setdefault(k, []).append(v)
return result | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_for_while_loop | def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_operand_swap | def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_rename_variable_cb | def group_keyvalue(l):
l2 = {}
for k, v in l:
l2.setdefault(k, []).append(v)
return l2 | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_rename_variable_naive | def group_keyvalue(l):
VAR_0 = {}
for k, v in l:
VAR_0.setdefault(k, []).append(v)
return VAR_0 | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
return result | transformation_rename_variable_rn | def group_keyvalue(l):
I9hU24 = {}
for k, v in l:
I9hU24.setdefault(k, []).append(v)
return I9hU24 | 1 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
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 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
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 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
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 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
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 | 171 | mbpp |
def group_keyvalue(l):
result = {}
for k, v in l:
result.setdefault(k, []).append(v)
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 | 171 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_dead_code_insert | def string_literals(patterns, text):
_i_1 = 0
if _i_1 < _i_1:
return "Not Matched!"
import re
for pattern in patterns:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_for_while_loop | def string_literals(patterns, text):
import re
_pattern_i = 0
while _pattern_i < len(patterns):
pattern = patterns[_pattern_i]
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!"
_pattern_i += 1 | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_operand_swap | def string_literals(patterns, text):
import re
for pattern in patterns:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_cb | def string_literals(pattern2, text):
import re
for pattern in pattern2:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_naive | def string_literals(patterns, VAR_0):
import re
for pattern in patterns:
if re.search(pattern, VAR_0):
return "Matched!"
else:
return "Not Matched!" | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_rn | def string_literals(sT7E4v28, text):
import re
for pattern in sT7E4v28:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 175 | mbpp |
def string_literals(patterns,text):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 175 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_dead_code_insert | def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
_i_7 = 0
if _i_7 < _i_7:
special_characters = re.findall(r"[, .!?]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_for_while_loop | def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_operand_swap | def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_rename_variable_cb | def find_character(line):
import re
uppercase_characters = re.findall(r"[A-Z]", line)
lowercase_characters = re.findall(r"[a-z]", line)
numerical_characters = re.findall(r"[0-9]", line)
special_characters = re.findall(r"[, .!?]", line)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_rename_variable_naive | def find_character(VAR_0):
import re
uppercase_characters = re.findall(r"[A-Z]", VAR_0)
lowercase_characters = re.findall(r"[a-z]", VAR_0)
numerical_characters = re.findall(r"[0-9]", VAR_0)
special_characters = re.findall(r"[, .!?]", VAR_0)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_rename_variable_rn | def find_character(Gt7990):
import re
uppercase_characters = re.findall(r"[A-Z]", Gt7990)
lowercase_characters = re.findall(r"[a-z]", Gt7990)
numerical_characters = re.findall(r"[0-9]", Gt7990)
special_characters = re.findall(r"[, .!?]", Gt7990)
return (
uppercase_characters,
lowercase_characters,
numerical_characters,
special_characters,
) | 1 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_sub_add_variable | def find_character(string):
import re
uppercase_characters = re.findall(r"[A+Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | 0 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | 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 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | 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 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | 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 | 179 | mbpp |
def find_character(string):
import re
uppercase_characters = re.findall(r"[A-Z]", string)
lowercase_characters = re.findall(r"[a-z]", string)
numerical_characters = re.findall(r"[0-9]", string)
special_characters = re.findall(r"[, .!?]", string)
return uppercase_characters, lowercase_characters, numerical_characters, special_characters | 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 | 179 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_dead_code_insert | def count_pairs(arr, n, k):
for _i_1 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] == k or arr[j] - arr[i] == k:
count += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_for_while_loop | def count_pairs(arr, n, k):
count = 0
i = 0
while i < n:
for j in range(i + 1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
i += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_operand_swap | def count_pairs(arr, n, k):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if k == arr[i] - arr[j] or arr[j] - arr[i] == k:
count += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_rename_variable_cb | def count_pairs(pairs, n, k):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if pairs[i] - pairs[j] == k or pairs[j] - pairs[i] == k:
count += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_rename_variable_naive | def count_pairs(VAR_0, n, k):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if VAR_0[i] - VAR_0[j] == k or VAR_0[j] - VAR_0[i] == k:
count += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_rename_variable_rn | def count_pairs(n3T, n, k):
count = 0
for i in range(0, n):
for j in range(i + 1, n):
if n3T[i] - n3T[j] == k or n3T[j] - n3T[i] == k:
count += 1
return count | 1 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_add_sub_variable | def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i-1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | 0 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_sub_add_variable | def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] + arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | 0 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_equalto_exclamation_variable | def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] != k or arr[j] - arr[i] == k:
count += 1
return count | 0 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
count += 1
return count | transformation_or_and_variable | def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k and arr[j] - arr[i] == k:
count += 1
return count | 0 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
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 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
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 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
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 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
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 | 180 | mbpp |
def count_pairs(arr, n, k):
count=0;
for i in range(0,n):
for j in range(i+1, n):
if arr[i] - arr[j] == k or arr[j] - arr[i] == k:
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 | 180 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_dead_code_insert | def check_literals(text, patterns):
import re
for pattern in patterns:
_i_3 = 0
while _i_3 < _i_3:
return "Not Matched!"
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_for_while_loop | def check_literals(text, patterns):
import re
_pattern_i = 0
while _pattern_i < len(patterns):
pattern = patterns[_pattern_i]
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!"
_pattern_i += 1 | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_operand_swap | def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_cb | def check_literals(text, patterns2):
import re
for pattern in patterns2:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_naive | def check_literals(VAR_0, patterns):
import re
for pattern in patterns:
if re.search(pattern, VAR_0):
return "Matched!"
else:
return "Not Matched!" | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_rename_variable_rn | def check_literals(text, z1W0DW2q):
import re
for pattern in z1W0DW2q:
if re.search(pattern, text):
return "Matched!"
else:
return "Not Matched!" | 1 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | transformation_dissimilar_code_injection_1 | def similar_elements(test_tup1, test_tup2):
res = tuple(set(test_tup1) & set(test_tup2))
return (res) | 0 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 183 | mbpp |
def check_literals(text, patterns):
import re
for pattern in patterns:
if re.search(pattern, text):
return ('Matched!')
else:
return ('Not Matched!') | 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 | 183 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_dead_code_insert | def first_Missing_Positive(arr, n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
_i_9 = 0
while _i_9 < _i_9:
arr[i] = 1
return 1
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return i + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_for_while_loop | def first_Missing_Positive(arr, n):
ptr = 0
i = 0
while i < n:
if arr[i] == 1:
ptr = 1
break
i += 1
if ptr == 0:
return 1
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return i + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_operand_swap | def first_Missing_Positive(arr, n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if 0 == ptr:
return 1
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return i + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_rename_variable_cb | def first_Missing_Positive(arr, n):
ptr = 0
for i2 in range(n):
if arr[i2] == 1:
ptr = 1
break
if ptr == 0:
return 1
for i2 in range(n):
if arr[i2] <= 0 or arr[i2] > n:
arr[i2] = 1
for i2 in range(n):
arr[(arr[i2] - 1) % n] += n
for i2 in range(n):
if arr[i2] <= n:
return i2 + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_rename_variable_naive | def first_Missing_Positive(arr, n):
ptr = 0
for VAR_0 in range(n):
if arr[VAR_0] == 1:
ptr = 1
break
if ptr == 0:
return 1
for VAR_0 in range(n):
if arr[VAR_0] <= 0 or arr[VAR_0] > n:
arr[VAR_0] = 1
for VAR_0 in range(n):
arr[(arr[VAR_0] - 1) % n] += n
for VAR_0 in range(n):
if arr[VAR_0] <= n:
return VAR_0 + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_rename_variable_rn | def first_Missing_Positive(arr, n):
ptr = 0
for z in range(n):
if arr[z] == 1:
ptr = 1
break
if ptr == 0:
return 1
for z in range(n):
if arr[z] <= 0 or arr[z] > n:
arr[z] = 1
for z in range(n):
arr[(arr[z] - 1) % n] += n
for z in range(n):
if arr[z] <= n:
return z + 1
return n + 1 | 1 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_add_sub_variable | def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] -= n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | 0 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_sub_add_variable | def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] + 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | 0 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_lesser_greater_variable | def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] >= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | 0 | 186 | mbpp |
def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] > n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | transformation_greater_lesser_variable | def first_Missing_Positive(arr,n):
ptr = 0
for i in range(n):
if arr[i] == 1:
ptr = 1
break
if ptr == 0:
return(1)
for i in range(n):
if arr[i] <= 0 or arr[i] < n:
arr[i] = 1
for i in range(n):
arr[(arr[i] - 1) % n] += n
for i in range(n):
if arr[i] <= n:
return(i + 1)
return(n + 1) | 0 | 186 | mbpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.