message stringlengths 2 433k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,086 | 12 | 32,172 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
import sys
input = lambda: sys.stdin.readline().rstrip()
for _ in range(int(input())):
n,m=map(str,input().split())
n=int(n)
l=[]; g=[]; buf=[n] ; li=n-1 ; gi=2
for i in m:
if i=='>':
while buf:
l.append(buf.pop())
l.append(li)
li-=1
else:
buf.append(li)
li-=1
while buf:
l.append(buf.pop())
buf=[1]
for i in range(len(m)):
if m[i]=='>':
if l[i]<l[i+1]: l[i],l[i+1]=l[i+1],li[i]
else:
if l[i]>l[i+1]: l[i],l[i+1]=l[i+1],l[i]
for i in m:
if i=='<':
while buf:
g.append(buf.pop())
g.append(gi)
gi+=1
else:
buf.append(gi)
gi+=1
while buf:
g.append(buf.pop())
for i in range(len(m)):
if m[i]=='>':
if g[i]<g[i+1]: g[i],g[i+1]=g[i+1],g[i]
else:
if g[i]>g[i+1]: g[i],g[i+1]=g[i+1],g[i]
print(*l)
print(*g)
``` | output | 1 | 16,086 | 12 | 32,173 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,087 | 12 | 32,174 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
# Legends Always Come Up with Solution
# Author: Manvir Singh
import os
import sys
from io import BytesIO, IOBase
def main():
for _ in range(int(input())):
n, s = input().split()
n = int(n)
ans = []
p, i = n, 0
while i < n - 1:
if s[i] == ">":
ans.append(p)
p -= 1
else:
j = i
a = [p]
p -= 1
while j < n - 1 and s[j] == "<":
j += 1
a.append(p)
p -= 1
while a:
ans.append(a.pop())
i = j
i += 1
if len(ans)!=n:
ans.append(p)
ans1 = []
p, i = n, n - 2
while i > -1:
if s[i] == "<":
ans1.append(p)
p -= 1
else:
j = i
a = [p]
p -= 1
while j > -1 and s[j] == ">":
j -= 1
a.append(p)
p -= 1
while a:
ans1.append(a.pop())
i = j
i -= 1
if len(ans1)!=n:
ans1.append(p)
ans1.reverse()
print(*ans)
print(*ans1)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
main()
``` | output | 1 | 16,087 | 12 | 32,175 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,088 | 12 | 32,176 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
from sys import stdin, stdout
from collections import deque, Counter
from copy import copy
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
def main():
T = int(rl())
for _ in range(T):
line = rll()
n, s = int(line[0]), line[1]
runs, L = [], 0
inc, dec = 0, 0
for R in range(len(s)+1):
if R == len(s) or s[R] != s[L]:
runlen = R-L if L > 0 else R-L+1
runs.append((runlen, s[L]))
if s[L] == "<":
inc += runlen
else:
dec += runlen
L = R
short = []
inc_ptr, dec_ptr = n, dec
for rlen, rtype in runs:
local = deque()
if rtype == "<":
for _ in range(rlen):
local.appendleft(inc_ptr)
inc_ptr -= 1
short.extend(local)
else:
for _ in range(rlen):
local.append(dec_ptr)
dec_ptr -= 1
short.extend(local)
long_ = [] # 3 < 4 < 5 < 6 > 2 > 1 < 7, inc = 5, dec = 2
inc_ptr, dec_ptr = n-inc+1, 1
for rlen , rtype in runs:
local = deque()
if rtype == "<":
for _ in range(rlen):
local.append(inc_ptr)
inc_ptr += 1
long_.extend(local)
else:
for _ in range(rlen):
local.appendleft(dec_ptr)
dec_ptr += 1
long_.extend(local)
shortLIS = " ".join(str(x) for x in short)
longLIS = " ".join(str(x) for x in long_)
stdout.write(str(shortLIS));stdout.write("\n")
stdout.write(str(longLIS));stdout.write("\n")
if __name__ == "__main__":
main()
``` | output | 1 | 16,088 | 12 | 32,177 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS. | instruction | 0 | 16,089 | 12 | 32,178 |
Tags: constructive algorithms, graphs, greedy, two pointers
Correct Solution:
```
from sys import stdin, stdout
from collections import deque, Counter
from copy import copy
rl = lambda: stdin.readline()
rll = lambda: stdin.readline().split()
# > > < > > <
#a b c d e f g
def main():
T = int(rl())
for _ in range(T):
line = rll()
n, s = int(line[0]), line[1]
runs, L = [], 0
inc, dec = 0, 0
for R in range(len(s)+1):
if R == len(s) or s[R] != s[L]:
runlen = R-L if L > 0 else R-L+1
runs.append((runlen, s[L]))
if s[L] == "<":
inc += runlen
else:
dec += runlen
L = R
# print(runs)
# print(inc, dec)
short = []
inc_ptr, dec_ptr = n, dec
for rlen, rtype in runs:
local = deque()
if rtype == "<":
for _ in range(rlen):
local.appendleft(inc_ptr)
inc_ptr -= 1
short.extend(local)
else:
for _ in range(rlen):
local.append(dec_ptr)
dec_ptr -= 1
short.extend(local)
long_ = [] # 3 < 4 < 5 < 6 > 2 > 1 < 7, inc = 5, dec = 2
inc_ptr, dec_ptr = n-inc+1, 1
for rlen , rtype in runs:
local = deque()
if rtype == "<":
for _ in range(rlen):
local.append(inc_ptr)
inc_ptr += 1
long_.extend(local)
else:
for _ in range(rlen):
local.appendleft(dec_ptr)
dec_ptr += 1
long_.extend(local)
# stdout.write("SHORT: ")
# stdout.write(str(short));stdout.write("\n")
# stdout.write("LONG: ")
# stdout.write(str(long_));stdout.write("\n")
# stdout.write(str("~~"));stdout.write("\n")
shortLIS = " ".join(str(x) for x in short)
longLIS = " ".join(str(x) for x in long_)
stdout.write(str(shortLIS));stdout.write("\n")
stdout.write(str(longLIS));stdout.write("\n")
if __name__ == "__main__":
main()
``` | output | 1 | 16,089 | 12 | 32,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
cases = int(input())
for _ in range(cases):
l, s = input().split()
l = int(l)
seq = []
# find a min LIS
i = 0
prev = l
start_i = 0
while i <= len(s):
start_i = i
while i < len(s) and s[i] == '<':
i += 1
for n in range(prev - (i - start_i), prev+1):
seq.append(n)
prev -= i - start_i + 1
i += 1
print(' '.join([str(x) for x in seq]))
# find a max LIS
hi = 1
for c in s:
if c == '>':
hi += 1
seq = [hi]
lo = hi - 1
for c in s:
if c == '<':
hi += 1
seq.append(hi)
else:
seq.append(lo)
lo -= 1
print(' '.join([str(x) for x in seq]))
``` | instruction | 0 | 16,090 | 12 | 32,180 |
Yes | output | 1 | 16,090 | 12 | 32,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
import sys
input = sys.stdin.readline
Q = int(input())
Query = []
for _ in range(Q):
N, S = map(str, input().rstrip().split())
Query.append((int(N), list(S)))
for N, S in Query:
L = []
for i, s in enumerate(S):
if s == "<":
L.append(i)
L.append(N-1)
Ls = set(L)
Longans = [-1]*N
Shortans = [-1]*N
P = []
k = []
pre = -2
for i, l in enumerate(L):
Longans[l] = i+1
if l == pre + 1:
k.append(l)
else:
P.append(k)
k = [l]
pre = l
P.append(k)
count = 0
for k in reversed(P):
for n in k:
count += 1
Shortans[n] = count
for i in reversed(range(N)):
if not i in Ls:
count += 1
Longans[i] = count
Shortans[i] = count
print(*Shortans, sep=" ")
print(*Longans, sep=" ")
``` | instruction | 0 | 16,091 | 12 | 32,182 |
Yes | output | 1 | 16,091 | 12 | 32,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
# Adapted from solution https://codeforces.com/blog/entry/73934
t = int(input())
for test_case in range(t):
n, pattern = input().split()
n = int(n)
ans = [0] * n
num, last = n, 0
for i in range(n):
if (i == n-1 or pattern[i] == ">"):
for j in range(i, last-1, -1):
ans[j] = num
num -= 1
last = i + 1
print(" ".join(str(k) for k in ans))
num, last = 1, 0
for i in range(n):
if (i == n-1 or pattern[i] == "<"):
for j in range(i, last-1, -1):
ans[j] = num
num += 1
last = i + 1
print(" ".join(str(k) for k in ans))
``` | instruction | 0 | 16,092 | 12 | 32,184 |
Yes | output | 1 | 16,092 | 12 | 32,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
t = int(input())
while t:
t-=1
n,s = input().split()
n = int(n)
cur = n
ans = [0]*n
last = -1
for i in range(n):
if i==n-1 or s[i]=='>':
for j in range(i,last,-1):
ans[j] = cur
cur-=1
last = i
print(' '.join(map(str,ans)))
cur = 1
last = -1
for i in range(n):
if i==n-1 or s[i]=='<':
for j in range(i,last,-1):
ans[j] = cur
cur+=1
last = i
print(' '.join(map(str,ans)))
``` | instruction | 0 | 16,093 | 12 | 32,186 |
Yes | output | 1 | 16,093 | 12 | 32,187 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n,s=map(str, input().split())
n=int(n)
a=[0 for i in range(n)]
a[0]=0
mi=0
for i in range(1,n):
if s[i-1]=='>':
a[i]=a[i-1]-1
else:
a[i]=a[i-1]+1
mi=min(mi,a[i])
mi*=-1
d=dict()
ma=0
for i in range(n):
a[i]+=mi+1
if a[i] in d:
d[a[i]].append(i)
else:
d[a[i]]=[i]
ma=max(ma,a[i])
limit=n
ans=[0 for i in range(n)]
for i in range(ma,0,-1):
sq=[]
for j in d[i]:
p=j
sq.append(p)
sq.sort()
sq.reverse()
for j in sq:
ans[j]=limit
limit-=1
limit=1
ans2=[0 for i in range(n)]
for i in range(1,ma+1):
sq=[]
for j in d[i]:
sq.append(j)
sq.sort()
for j in sq:
ans2[j]=limit
limit+=1
print(*ans2)
print(*ans)
``` | instruction | 0 | 16,094 | 12 | 32,188 |
No | output | 1 | 16,094 | 12 | 32,189 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
from collections import Counter
import math as mt
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
def gcd(a, b):
if a == 0:
return b
return gcd(b % a, a)
def lcm(a, b):
return (a * b) / gcd(a, b)
mod = int(1e9) + 7
def power(k, n):
if n == 0:
return 1
if n % 2:
return (power(k, n - 1) * k) % mod
t = power(k, n // 2)
return (t * t) % mod
def totalPrimeFactors(n):
count = 0
if (n % 2) == 0:
count += 1
while (n % 2) == 0:
n //= 2
i = 3
while i * i <= n:
if (n % i) == 0:
count += 1
while (n % i) == 0:
n //= i
i += 2
if n > 2:
count += 1
return count
# #MAXN = int(1e7 + 1)
# # spf = [0 for i in range(MAXN)]
#
#
# def sieve():
# spf[1] = 1
# for i in range(2, MAXN):
# spf[i] = i
# for i in range(4, MAXN, 2):
# spf[i] = 2
#
# for i in range(3, mt.ceil(mt.sqrt(MAXN))):
# if (spf[i] == i):
# for j in range(i * i, MAXN, i):
# if (spf[j] == j):
# spf[j] = i
#
#
# def getFactorization(x):
# ret = 0
# while (x != 1):
# k = spf[x]
# ret += 1
# # ret.add(spf[x])
# while x % k == 0:
# x //= k
#
# return ret
# Driver code
# precalculating Smallest Prime Factor
# sieve()
def main():
for _ in range(int(input())):
n,S=input().split()
n=int(n)
s=[]
ss=[]
for i in range(n-1):
s.append(S[i])
if S[i]=='>':
ss.append('<')
else:
ss.append('>')
ss.reverse()
ans=[n]
l, r=n,n
for i in range(n-1):
if s[i]=='<':
r+=1
ans.append(r)
else:
l-=1
ans.append(l)
t=1-min(ans)
#print(ans)
for i in range(n):
ans[i]+=t
t=max(ans)-n
for i in range(n):
ans[i]-=t
print(ans[i], end=' ')
print('')
ans = [n]
l, r = n, n
for i in range(n - 1):
if ss[i] == '<':
r += 1
ans.append(r)
else:
l -= 1
ans.append(l)
t = 1 - min(ans)
for i in range(n):
ans[i] += t
t = max(ans) - n
ans.reverse()
for i in range(n):
ans[i] -= t
print(ans[i], end=' ')
print('')
return
if __name__ == "__main__":
main()
``` | instruction | 0 | 16,095 | 12 | 32,190 |
No | output | 1 | 16,095 | 12 | 32,191 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
t = int(input())
total_res = []
for x in range(t):
n, s = input().split()
n = int(n)
curr_index = 1
res = ''
curr_streak = 1
for i in range(n - 2, -1, -1):
if s[i] == '<':
curr_streak += 1
else:
temp = ''
for j in range(curr_streak):
temp += str(curr_index)
curr_index += 1
res = temp + res
curr_streak = 1
temp = ''
for j in range(curr_streak):
temp += str(curr_index)
curr_index += 1
res = temp + res
total_res.append(res)
curr_index = 1
res = ''
curr_streak = 1
for i in range(n - 1):
if s[i] == '>':
curr_streak += 1
else:
temp = ''
for j in range(curr_streak):
temp = str(curr_index) + temp
curr_index += 1
res += temp
curr_streak = 1
temp = ''
for j in range(curr_streak):
temp = str(curr_index) + temp
curr_index += 1
res += temp
total_res.append(res)
for item in total_res:
for char in item:
print(char, end = ' ')
print()
``` | instruction | 0 | 16,096 | 12 | 32,192 |
No | output | 1 | 16,096 | 12 | 32,193 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Gildong recently learned how to find the [longest increasing subsequence](https://en.wikipedia.org/wiki/Longest_increasing_subsequence) (LIS) in O(nlog{n}) time for a sequence of length n. He wants to test himself if he can implement it correctly, but he couldn't find any online judges that would do it (even though there are actually many of them). So instead he's going to make a quiz for you about making permutations of n distinct integers between 1 and n, inclusive, to test his code with your output.
The quiz is as follows.
Gildong provides a string of length n-1, consisting of characters '<' and '>' only. The i-th (1-indexed) character is the comparison result between the i-th element and the i+1-st element of the sequence. If the i-th character of the string is '<', then the i-th element of the sequence is less than the i+1-st element. If the i-th character of the string is '>', then the i-th element of the sequence is greater than the i+1-st element.
He wants you to find two possible sequences (not necessarily distinct) consisting of n distinct integers between 1 and n, inclusive, each satisfying the comparison results, where the length of the LIS of the first sequence is minimum possible, and the length of the LIS of the second sequence is maximum possible.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 10^4).
Each test case contains exactly one line, consisting of an integer and a string consisting of characters '<' and '>' only. The integer is n (2 ≤ n ≤ 2 ⋅ 10^5), the length of the permutation you need to find. The string is the comparison results explained in the description. The length of the string is n-1.
It is guaranteed that the sum of all n in all test cases doesn't exceed 2 ⋅ 10^5.
Output
For each test case, print two lines with n integers each. The first line is the sequence with the minimum length of the LIS, and the second line is the sequence with the maximum length of the LIS. If there are multiple answers, print any one of them. Each sequence should contain all integers between 1 and n, inclusive, and should satisfy the comparison results.
It can be shown that at least one answer always exists.
Example
Input
3
3 <<
7 >><>><
5 >>><
Output
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
Note
In the first case, 1 2 3 is the only possible answer.
In the second case, the shortest length of the LIS is 2, and the longest length of the LIS is 3. In the example of the maximum LIS sequence, 4 '3' 1 7 '5' 2 '6' can be one of the possible LIS.
Submitted Solution:
```
"""T=int(input())
for _ in range(0,T):
N=int(input())
a,b=map(int,input().split())
s=input()
s=[int(x) for x in input().split()]
for i in range(0,len(s)):
a,b=map(int,input().split())"""
"""
T=int(input())
for _ in range(0,T):
tt=input().split()
n=int(tt[0])
s=str(tt[1])
mx=[]
mn=[]
L=[]
c=1
for i in range(1,len(s)):
if(s[i]!=s[i-1]):
L.append((s[i-1],c))
c=1
else:
c+=1
L.append((s[-1],c))
ptr=1
for i in range(0,len(L)):
if(L[i][0]=='>'):
h=[]
for j in range(L[i][1]+1):
h.append(ptr)
ptr+=1
h=h[::-1]
mx+=h
else:
h=[]
for j in range(L[i][1]):
h.append(ptr)
ptr+=1
mx+=h
print(*mx)
ptr=n
for i in range(0,len(L)):
if(L[i][0]=='>'):
h=[]
for j in range(L[i][1]):
h.append(ptr)
ptr-=1
mn+=h
else:
h=[]
for j in range(L[i][1]+1):
h.append(ptr)
ptr-=1
h=h[::-1]
mn+=h
print(*mn)
"""
"""T=int(input())
for _ in range(0,T):
N=int(input())
a,b=map(int,input().split())
s=input()
s=[int(x) for x in input().split()]
for i in range(0,len(s)):
a,b=map(int,input().split())"""
T=int(input())
for _ in range(0,T):
tt=input().split()
n=int(tt[0])
s=str(tt[1])
mx=[]
vismx=[0]*(n+1)
mn=[]
vismn=[0]*(n+1)
L=[]
c=1
for i in range(1,len(s)):
if(s[i]!=s[i-1]):
L.append((s[i-1],c))
c=1
else:
c+=1
L.append((s[-1],c))
"""ptr1=1
ptr2=n
L=L[::-1]
for i in range(0,len(L)):
if(L[i][0]=='>'):
h=[]
for j in range(L[i][1]):
h.append(ptr2)
ptr2-=1
h=h[::-1]
mn+=h
else:
h=[]
for j in range(L[i][1]):
h.append(ptr1)
ptr1+=1
h=h[::-1]
mn+=h
mn.append(1)
mn=mn[::-1]
print(*mn)"""
ptr1=1
ptr2=n
L=L[::-1]
if(s[-1]=='>'):
mn.append(1)
ptr1+=1
for i in range(0,len(L)):
if(L[i][0]=='>'):
for j in range(L[i][1]-1):
mn.append(ptr1)
vismn[ptr1]=1
ptr1+=1
else:
h=[]
for j in range(L[i][1]+1):
h.append(ptr1)
vismn[ptr1]=1
ptr1+=1
h=h[::-1]
mn+=h
for i in range(1,len(vismn)):
if(vismn[i]==0):
mn.append(i)
break
mn=mn[::-1]
print(*mn)
ptr1=1
ptr2=n
L=L[::-1]
for i in range(0,len(L)):
if(L[i][0]=='>'):
for j in range(L[i][1]):
mx.append(ptr2)
vismx[ptr2]=1
ptr2-=1
else:
for j in range(L[i][1]):
mx.append(ptr1)
vismx[ptr1]=1
ptr1+=1
for i in range(1,len(vismx)):
if(vismx[i]==0):
mx.append(i)
break
print(*mx)
``` | instruction | 0 | 16,097 | 12 | 32,194 |
No | output | 1 | 16,097 | 12 | 32,195 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,210 | 12 | 32,420 |
Tags: constructive algorithms, implementation
Correct Solution:
```
from collections import deque
def odwroc(n,l):
ustalone = [l[0]]
maks = l[0]
for i in range(1,n):
if l[i] == maks:
ustalone.append('x')
else:
ustalone.append(l[i])
maks = l[i]
return ustalone
def maxmin(n,p):
mi,ma = p.copy(),p.copy()
maxx,minn = deque(), deque()
maks = 0
for i in range(n):
ob = ma[i]
if ob == 'x':
ma[i] = maxx.pop()
mi[i] = minn.popleft()
else:
maxx.extend(range(maks+1,ma[i]))
minn.extend(range(maks+1,ma[i]))
maks = ma[i]
print(' '.join(list(map(str, mi))))
print(' '.join(list(map(str, ma))))
return
def main():
t = input()
for i in range(int(t)):
n = int(input())
maxmin(n, odwroc(n, list(map(int, input().split()))))
return
main()
``` | output | 1 | 16,210 | 12 | 32,421 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,211 | 12 | 32,422 |
Tags: constructive algorithms, implementation
Correct Solution:
```
# Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
def solvemn(arr,v):
l=0
for i in range(len(arr)):
if arr[i]==0:
while v[l]:
l+=1
arr[i]=l
l+=1
return
def solvemx(arr,v):
prev=arr[0]
for i in range(1,len(arr)):
if arr[i]==prev:
l=prev
while v[l]:
l-=v[l]
v[prev]=prev-l+1
arr[i]=l
else:
prev=arr[i]
return
def main():
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
mn=[0]*(n)
mn[0]=arr[0]
vis=[0]*(n+1)
vis[mn[0]]=1
vis[0]=1
for i in range(1,n):
if arr[i]==arr[i-1]:
continue
mn[i]=arr[i]
vis[arr[i]]=1
solvemn(mn,vis.copy())
solvemx(arr,vis)
print(*mn)
print(*arr)
# print(*vis)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main()
``` | output | 1 | 16,211 | 12 | 32,423 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,212 | 12 | 32,424 |
Tags: constructive algorithms, implementation
Correct Solution:
```
from collections import deque
import sys
input=sys.stdin.readline
t=int(input())
for _ in range(t):
n=int(input())
a=list(map(int,input().split()))
a=[0]+a
minimal=[]
maximal=[]
s=deque([])
for i in range(1,len(a)):
if a[i]!=a[i-1]:
maximal.append(a[i])
for j in range(a[i-1]+1,a[i]):
s.appendleft(j)
else:
maximal.append(s.popleft())
s=deque([])
for i in range(1,len(a)):
if a[i]!=a[i-1]:
minimal.append(a[i])
for j in range(a[i-1]+1,a[i]):
s.append(j)
else:
minimal.append(s.popleft())
print(*minimal)
print(*maximal)
``` | output | 1 | 16,212 | 12 | 32,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,213 | 12 | 32,426 |
Tags: constructive algorithms, implementation
Correct Solution:
```
def main():
tt = int(input())
while tt > 0:
tt -= 1
n = int(input())
a = [int(u) for u in input().split()]
ans1 = [0 for i in range(n)]
prev = 0
not_used = []
for i in range(n):
if a[i] != prev:
ans1[i] = a[i]
for j in range(prev + 1, a[i]):
not_used.append(j)
prev = a[i]
not_used.reverse()
for i in range(n):
if ans1[i] == 0:
ans1[i] = not_used.pop()
for i in range(n):
print(ans1[i], end=' ')
print()
not_used = []
ans2 = [0 for i in range(n)]
prev = 0
for i in range(n):
if a[i] != prev:
ans2[i] = a[i]
for j in range(prev + 1, a[i]):
not_used.append(j)
prev = a[i]
else:
ans2[i] = not_used.pop()
for i in range(n):
print(ans2[i], end=' ')
print()
if __name__ == '__main__':
main()
``` | output | 1 | 16,213 | 12 | 32,427 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,214 | 12 | 32,428 |
Tags: constructive algorithms, implementation
Correct Solution:
```
import sys
input = sys.stdin.readline
for nt in range(int(input())):
n = int(input())
a = list(map(int,input().split()))
minn = [0]*n
minn[0] = a[0]
for i in range(1, n):
if a[i]!=a[i-1]:
minn[i] = a[i]
s = set(minn)
curr = 1
for i in range(n):
if minn[i]==0:
while curr in s:
curr += 1
minn[i] = curr
curr += 1
print (*minn)
maxx = [0]*n
maxx[0] = a[0]
for i in range(1, n):
if a[i]!=a[i-1]:
maxx[i] = a[i]
s = set(maxx)
curr = n
left = []
prev = 0
for i in range(n):
if maxx[i]==0:
maxx[i] = left.pop()
else:
for j in range(prev+1, maxx[i]):
left.append(j)
prev = maxx[i]
# print (left)
print (*maxx)
``` | output | 1 | 16,214 | 12 | 32,429 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,215 | 12 | 32,430 |
Tags: constructive algorithms, implementation
Correct Solution:
```
if __name__ == '__main__':
for _ in range (int(input())):
n = int(input())
l = list(map(int, input().split()))
b = l.copy()
d = {l[0]:0}
ans = [l[0]]
a = []
for i in range (1,n):
d.setdefault(l[i],i)
if b[i]==b[i-1]:
l[i]='X'
else:
ans.append(l[i])
for i in range (1,n+1):
d.setdefault(i,-1)
if d[i] == -1:
a.append(i)
ans1 = l.copy()
i = 0
k = 0
while i < len(ans) :
j = d[ans[i]]+1
if j < n:
while ans1[j] == 'X':
ans1[j]=a[k]
k+=1
j+=1
if j == n:
break
i+=1
k = 1
ans2 = l.copy()
i = 0
s = []
while i < len(ans) :
j = d[ans[i]]+1
if j < n:
while ans2[j] == 'X':
while k < ans[i]:
if d[k] == -1:
s.append(k)
d[k] = -2
k+=1
ans2[j] = s.pop()
j+=1
if j == n:
break
i+=1
print(*ans1)
print(*ans2)
``` | output | 1 | 16,215 | 12 | 32,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,216 | 12 | 32,432 |
Tags: constructive algorithms, implementation
Correct Solution:
```
'''Author- Akshit Monga'''
from sys import stdin, stdout
input = stdin.readline
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
t = int(input())
for _ in range(t):
n=int(input())
a=[int(x) for x in input().split()]
p1=[-1 for i in range(n)]
p2=[-1 for i in range(n)]
last=-1
for i in range(n):
if a[i]!=last:
last=a[i]
p1[i]=a[i]
p2[i]=a[i]
x=set(a)
vals=[]
for i in range(1,n+1):
if i not in x:
vals.append(i)
c=0
for i in range(n):
if p1[i]==-1:
p1[i]=vals[c]
c+=1
# print(p1)
vals=SortedList(vals)
x=sorted(x)
# if len(x)==1:
# print(*p1)
# p2=[i for i in range(1,n+1)]
# print(*p2[::-1])
# continue
print(*p1)
c=0
x.append(float('inf'))
for i in range(1,n):
if p2[i]!=-1:
c+=1
continue
ind=vals.bisect_left(x[c])-1
p2[i]=vals[ind]
vals.remove(vals[ind])
print(*p2)
``` | output | 1 | 16,216 | 12 | 32,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1 | instruction | 0 | 16,217 | 12 | 32,434 |
Tags: constructive algorithms, implementation
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
q=list(map(int,input().split()))
maxy=[]
miny=[]
M=[]
m=[]
count=1
i=0
j=0
while i<n:
num=q[i]
while num>count:
maxy.append(count)
miny.append(count)
count=count+1
count=count+1
i=i+1
M.append(num)
m.append(num)
if i<n:
while num==q[i]:
m.append(miny[j])
j+=1
M.append(maxy[-1])
maxy.pop()
i+=1
if i==n:
break
print(*m)
print(*M)
``` | output | 1 | 16,217 | 12 | 32,435 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
from collections import deque
cas=int(input());
while cas:
cas-=1;
n=int(input());
a=list(map(int,input().split()));
ans1=[]
tmp1=deque()
ans2=[]
tmp2=deque()
for i in range(n):
if(i==0):
for j in range(1,a[i]):
tmp1.append(j)
tmp2.append(j)
ans1.append(a[i])
ans2.append(a[i])
elif(a[i]!=a[i-1]):
for j in range(a[i-1]+1,a[i]):
tmp1.append(j)
tmp2.append(j)
ans1.append(a[i])
ans2.append(a[i])
else:
ans1.append(tmp1.pop());
ans2.append(tmp2.popleft());
for i in range(n):
if(i==n-1):
print(ans2[i]);
else:
print(ans2[i],end=' ');
for i in range(n):
if(i==n-1):
print(ans1[i]);
else:
print(ans1[i],end=' ');
``` | instruction | 0 | 16,218 | 12 | 32,436 |
Yes | output | 1 | 16,218 | 12 | 32,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
import bisect
import collections
import functools
import itertools
import math
import heapq
import random
import string
def repeat(_func=None, *, times=1):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
for _ in range(times):
func(*args, **kwargs)
return wrapper
if _func is None:
return decorator
else:
return decorator(_func)
def unpack(func=int):
return map(func, input().split())
def l_unpack(func=int):
"""list unpack"""
return list(map(func, input().split()))
def getint():
return int(input())
def getmatrix(rows):
return [list(map(int, input().split())) for _ in range(rows)]
def display_matrix(mat):
for i in range(len(mat)):
print(mat[i])
def util(arr, n, minmax):
output = [-1] * n
vstd = [False] * (n + 1)
vstd[arr[0]] = True
output[0] = arr[0]
hp = [minmax * x for x in range(1, arr[0])]
heapq.heapify(hp)
maxi = arr[0] - 1
heappush, heappop = heapq.heappush, heapq.heappop
for i in range(1, n):
if arr[i] > arr[i - 1]:
output[i] = arr[i]
vstd[arr[i]] = True
while maxi + 1 < arr[i]:
maxi += 1
if not vstd[maxi]:
heappush(hp, minmax * maxi)
else:
while vstd[minmax * hp[0]]:
heappop(hp)
output[i] = minmax * heappop(hp)
vstd[output[i]] = True
return output
@repeat(times=int(input()))
def main():
n = getint()
arr = l_unpack()
lmin = util(arr, n, 1)
print(*lmin)
lmax = util(arr, n, -1)
print(*lmax)
MOD = 10 ** 9 + 7
main()
``` | instruction | 0 | 16,219 | 12 | 32,438 |
Yes | output | 1 | 16,219 | 12 | 32,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
import sys
import math
import heapq
import bisect
from collections import Counter
from collections import defaultdict
from io import BytesIO, IOBase
import string
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
import os
self.os = os
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
self.BUFSIZE = 8192
def read(self):
while True:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
self.os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
def get_int():
return int(input())
def get_ints():
return list(map(int, input().split(' ')))
def get_int_grid(n):
return [get_ints() for _ in range(n)]
def get_str():
return input().strip()
def get_strs():
return get_str().split(' ')
def flat_list(arr):
return [item for subarr in arr for item in subarr]
def yes_no(b):
if b:
return "YES"
else:
return "NO"
def binary_search(good, left, right, delta=1, right_true=False):
"""
Performs binary search
----------
Parameters
----------
:param good: Function used to perform the binary search
:param left: Starting value of left limit
:param right: Starting value of the right limit
:param delta: Margin of error, defaults value of 1 for integer binary search
:param right_true: Boolean, for whether the right limit is the true invariant
:return: Returns the most extremal value interval [left, right] which is good function evaluates to True,
alternatively returns False if no such value found
"""
limits = [left, right]
while limits[1] - limits[0] > delta:
if delta == 1:
mid = sum(limits) // 2
else:
mid = sum(limits) / 2
if good(mid):
limits[int(right_true)] = mid
else:
limits[int(~right_true)] = mid
if good(limits[int(right_true)]):
return limits[int(right_true)]
else:
return False
def prefix_sums(a):
p = [0]
for x in a:
p.append(p[-1] + x)
return p
def solve_a():
n, m, x = get_ints()
row, col = (x - 1) % n, (x - 1) // n
return row * m + col + 1
def solve_b():
n, k = get_ints()
s = list(get_str())
stars = [idx for idx in range(n) if s[idx] == '*']
m = len(stars)
idx = 0
while idx < m:
s[stars[idx]] = 'x'
jdx = idx + 1
while jdx < m - 1 and stars[jdx + 1] - stars[idx] <= k:
jdx += 1
idx = jdx
return s.count('x')
def solve_c():
a = get_str()
b = get_str()
n = len(a)
m = len(b)
tmp = 0
for i in range(n):
for j in range(i, n):
if a[i:j+1] in b:
tmp = max(tmp, j - i + 1)
return m + n - 2 * tmp
def solve_d():
n = get_int()
arr = get_ints()
c = [-x for x in Counter(arr).values()]
heapq.heapify(c)
while len(c) > 1:
x = -heapq.heappop(c)-1
y = -heapq.heappop(c)-1
if x:
heapq.heappush(c, -x)
if y:
heapq.heappush(c, -y)
return -sum(c)
class SortedList:
def __init__(self, iterable=[], _load=200):
"""Initialize sorted list instance."""
values = sorted(iterable)
self._len = _len = len(values)
self._load = _load
self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
self._list_lens = [len(_list) for _list in _lists]
self._mins = [_list[0] for _list in _lists]
self._fen_tree = []
self._rebuild = True
def _fen_build(self):
"""Build a fenwick tree instance."""
self._fen_tree[:] = self._list_lens
_fen_tree = self._fen_tree
for i in range(len(_fen_tree)):
if i | i + 1 < len(_fen_tree):
_fen_tree[i | i + 1] += _fen_tree[i]
self._rebuild = False
def _fen_update(self, index, value):
"""Update `fen_tree[index] += value`."""
if not self._rebuild:
_fen_tree = self._fen_tree
while index < len(_fen_tree):
_fen_tree[index] += value
index |= index + 1
def _fen_query(self, end):
"""Return `sum(_fen_tree[:end])`."""
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
x = 0
while end:
x += _fen_tree[end - 1]
end &= end - 1
return x
def _fen_findkth(self, k):
"""Return a pair of (the largest `idx` such that `sum(_fen_tree[:idx]) <= k`, `k - sum(_fen_tree[:idx])`)."""
_list_lens = self._list_lens
if k < _list_lens[0]:
return 0, k
if k >= self._len - _list_lens[-1]:
return len(_list_lens) - 1, k + _list_lens[-1] - self._len
if self._rebuild:
self._fen_build()
_fen_tree = self._fen_tree
idx = -1
for d in reversed(range(len(_fen_tree).bit_length())):
right_idx = idx + (1 << d)
if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
idx = right_idx
k -= _fen_tree[idx]
return idx + 1, k
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`."""
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len -= 1
self._fen_update(pos, -1)
del _lists[pos][idx]
_list_lens[pos] -= 1
if _list_lens[pos]:
_mins[pos] = _lists[pos][0]
else:
del _lists[pos]
del _list_lens[pos]
del _mins[pos]
self._rebuild = True
def _loc_left(self, value):
"""Return an index pair that corresponds to the first position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
lo, pos = -1, len(_lists) - 1
while lo + 1 < pos:
mi = (lo + pos) >> 1
if value <= _mins[mi]:
pos = mi
else:
lo = mi
if pos and value <= _lists[pos - 1][-1]:
pos -= 1
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value <= _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def _loc_right(self, value):
"""Return an index pair that corresponds to the last position of `value` in the sorted list."""
if not self._len:
return 0, 0
_lists = self._lists
_mins = self._mins
pos, hi = 0, len(_lists)
while pos + 1 < hi:
mi = (pos + hi) >> 1
if value < _mins[mi]:
hi = mi
else:
pos = mi
_list = _lists[pos]
lo, idx = -1, len(_list)
while lo + 1 < idx:
mi = (lo + idx) >> 1
if value < _list[mi]:
idx = mi
else:
lo = mi
return pos, idx
def add(self, value):
"""Add `value` to sorted list."""
_load = self._load
_lists = self._lists
_mins = self._mins
_list_lens = self._list_lens
self._len += 1
if _lists:
pos, idx = self._loc_right(value)
self._fen_update(pos, 1)
_list = _lists[pos]
_list.insert(idx, value)
_list_lens[pos] += 1
_mins[pos] = _list[0]
if _load + _load < len(_list):
_lists.insert(pos + 1, _list[_load:])
_list_lens.insert(pos + 1, len(_list) - _load)
_mins.insert(pos + 1, _list[_load])
_list_lens[pos] = _load
del _list[_load:]
self._rebuild = True
else:
_lists.append([value])
_mins.append(value)
_list_lens.append(1)
self._rebuild = True
def discard(self, value):
"""Remove `value` from sorted list if it is a member."""
_lists = self._lists
if _lists:
pos, idx = self._loc_right(value)
if idx and _lists[pos][idx - 1] == value:
self._delete(pos, idx - 1)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member."""
_len = self._len
self.discard(value)
if _len == self._len:
raise ValueError('{0!r} not in list'.format(value))
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
value = self._lists[pos][idx]
self._delete(pos, idx)
return value
def bisect_left(self, value):
"""Return the first index to insert `value` in the sorted list."""
pos, idx = self._loc_left(value)
return self._fen_query(pos) + idx
def bisect_right(self, value):
"""Return the last index to insert `value` in the sorted list."""
pos, idx = self._loc_right(value)
return self._fen_query(pos) + idx
def count(self, value):
"""Return number of occurrences of `value` in the sorted list."""
return self.bisect_right(value) - self.bisect_left(value)
def __len__(self):
"""Return the size of the sorted list."""
return self._len
def __getitem__(self, index):
"""Lookup value at `index` in sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
return self._lists[pos][idx]
def __delitem__(self, index):
"""Remove value at `index` from sorted list."""
pos, idx = self._fen_findkth(self._len + index if index < 0 else index)
self._delete(pos, idx)
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list."""
_lists = self._lists
if _lists:
pos, idx = self._loc_left(value)
return idx < len(_lists[pos]) and _lists[pos][idx] == value
return False
def __iter__(self):
"""Return an iterator over the sorted list."""
return (value for _list in self._lists for value in _list)
def __reversed__(self):
"""Return a reverse iterator over the sorted list."""
return (value for _list in reversed(self._lists) for value in reversed(_list))
def __repr__(self):
"""Return string representation of sorted list."""
return 'SortedList({0})'.format(list(self))
def solve_e():
n = get_int()
q = get_ints()
p = [i for i in range(1, n + 1)]
S1 = SortedList(p)
S2 = SortedList(p)
curr = 0
r1 = []
r2 = []
for i in range(n):
if q[i] == curr:
r1.append(S1.pop(0))
j = S2.bisect_left(q[i])
r2.append(S2.pop(j - 1))
else:
r1.append(q[i])
S1.remove(q[i])
r2.append(q[i])
S2.remove(q[i])
curr = q[i]
return r1, r2
t = get_int()
for _ in range(t):
for ans in solve_e():
print(*ans)
``` | instruction | 0 | 16,220 | 12 | 32,440 |
Yes | output | 1 | 16,220 | 12 | 32,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
import heapq
import sys
input = sys.stdin.readline
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
s = set()
e = []
for i in l:
if i in s:
continue
s.add(i)
for i in range(1,n+1):
if i in s:
continue
e.append(i)
a = e[::-1]
am = [0]*n
for i in range(n):
x = l[i]
if x in s:
am[i] = x
s.remove(x)
else:
am[i] = a.pop()
h = []
ama = [0]*n
heapq.heapify(h)
i = 0
prev = 0
while i < n:
j = i
while j < n:
if l[j] == l[i]:
pass
else:
break
j = j + 1
w = j
ama[i] = am[i]
k = i + 1
cnt = l[i] - 1
er = prev
prev = am[i]
while cnt > er:
heapq.heappush(h,-1*cnt)
cnt -= 1
while k < w:
cnt = -1*heapq.heappop(h)
ama[k] = cnt
k += 1
i = w
print(*am)
print(*ama)
``` | instruction | 0 | 16,221 | 12 | 32,442 |
Yes | output | 1 | 16,221 | 12 | 32,443 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
q = list(map(int, input(). split()))
p1 = [0] * n
p2 = [0] * n
p1[0] = q[0]
p2[0] = q[0]
k = q[0]
s = 1
p3 = [0] * n
p4 = [0] * n
w = n - 1
p3[k - 1] = 1
p4[k - 1] = 1
h = 1
for i in range(1, n):
if q[i] != k:
p1[i] = q[i]
p2[i] = q[i]
k = q[i]
p3[k - 1] = 1
p4[k - 1] = 1
else:
while p3[w] != 0 or w >= k - 1:
w = (w - 1) % n
p3[w] = 1
while p4[h - 1] != 0:
h += 1
p4[h - 1] = 1
p1[i] = h
p2[i] = w + 1
print(*p1)
print(*p2)
``` | instruction | 0 | 16,222 | 12 | 32,444 |
No | output | 1 | 16,222 | 12 | 32,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
def main():
t = int(input())
for _ in range(t):
n = int(input())
q = list(map(int,input().split()))
m = [0]*n
m2 = [0]*n
m[q[0]-1] = 1
m2[q[0]-1] = 1
start = 0
m2_start = q[0]-1
while True:
if start < n and m[start] == 1:
start+=1
else:
break
min_p = str(q[0])
max_p = str(q[0])
for i in range(1,n):
if q[i]== q[i-1]:
min_p+= ' '+ str(start+1)
m[start] = 1
m2_start = q[i]-1
while True:
if m2_start >-1 and m2[m2_start] == 1:
m2_start -= 1
elif m2_start > -1 and m2[m2_start] == 0:
break
max_p+= ' '+ str(m2_start+1)
m2[m2_start] = 1
while True:
if start<n and m[start] == 1:
start += 1
else:
break
else:
min_p+= ' '+ str(q[i])
max_p+= ' '+ str(q[i])
m[q[i]-1] = 1
m2[q[i]-1] = 1
#print(m)
print(min_p)
print(max_p)
if __name__ == "__main__":
main()
``` | instruction | 0 | 16,223 | 12 | 32,446 |
No | output | 1 | 16,223 | 12 | 32,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
"""
Accomplished using the EduTools plugin by JetBrains https://plugins.jetbrains.com/plugin/10081-edutools
"""
# from typing import Iterable, List
# def get_permutations(m: int, arr: Iterable[int]) -> tuple[List[int], List[int]]:
def get_permutations(m: int, arr) -> tuple:
nums = {i: False for i in range(1, m + 1)}
placeholder = []
previous_num = 0
for num in arr:
if num == previous_num:
placeholder.append(0)
else:
placeholder.append(num)
nums[num] = True
previous_num = num
remained_nums = sorted(j for j, v in nums.items() if not v)
minimum = placeholder.copy()
cp_remained_nums = remained_nums.copy()
tmp = 0
for i, num in enumerate(minimum):
if num != 0:
tmp = num
if num == 0:
for j in range(tmp):
if j in cp_remained_nums:
minimum[i] = j
cp_remained_nums.remove(j)
break
maximum = placeholder.copy()
cp_remained_nums = remained_nums.copy()
tmp = 0
for i, num in enumerate(maximum):
if num != 0:
tmp = num
if num == 0:
for j in range(tmp)[::-1]:
if j in cp_remained_nums:
maximum[i] = j
cp_remained_nums.remove(j)
break
return minimum, maximum
if __name__ == "__main__":
# Write your solution here
t = int(input().strip())
answers = {}
for i in range(t):
n: int = int(input().strip()) # array length
q = map(int, input().strip().split())
key = f'{n},{q}'
if key in answers.keys():
minimum, maximum = answers[key]
else:
answers[key] = get_permutations(n, q)
minimum, maximum = answers[key]
print(' '.join(map(str, minimum)) + ' ')
print(' '.join(map(str, maximum)), end='')
if i != t - 1:
print(' ')
else:
print('')
``` | instruction | 0 | 16,224 | 12 | 32,448 |
No | output | 1 | 16,224 | 12 | 32,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A permutation is a sequence of n integers from 1 to n, in which all numbers occur exactly once. For example, [1], [3, 5, 2, 1, 4], [1, 3, 2] are permutations, and [2, 3, 2], [4, 3, 1], [0] are not.
Polycarp was presented with a permutation p of numbers from 1 to n. However, when Polycarp came home, he noticed that in his pocket, the permutation p had turned into an array q according to the following rule:
* q_i = max(p_1, p_2, …, p_i).
Now Polycarp wondered what lexicographically minimal and lexicographically maximal permutations could be presented to him.
An array a of length n is lexicographically smaller than an array b of length n if there is an index i (1 ≤ i ≤ n) such that the first i-1 elements of arrays a and b are the same, and the i-th element of the array a is less than the i-th element of the array b. For example, the array a=[1, 3, 2, 3] is lexicographically smaller than the array b=[1, 3, 4, 2].
For example, if n=7 and p=[3, 2, 4, 1, 7, 5, 6], then q=[3, 3, 4, 4, 7, 7, 7] and the following permutations could have been as p initially:
* [3, 1, 4, 2, 7, 5, 6] (lexicographically minimal permutation);
* [3, 1, 4, 2, 7, 6, 5];
* [3, 2, 4, 1, 7, 5, 6];
* [3, 2, 4, 1, 7, 6, 5] (lexicographically maximum permutation).
For a given array q, find the lexicographically minimal and lexicographically maximal permutations that could have been originally presented to Polycarp.
Input
The first line contains one integer t (1 ≤ t ≤ 10^4). Then t test cases follow.
The first line of each test case contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5).
The second line of each test case contains n integers q_1, q_2, …, q_n (1 ≤ q_i ≤ n).
It is guaranteed that the array q was obtained by applying the rule from the statement to some permutation p.
It is guaranteed that the sum of n over all test cases does not exceed 2 ⋅ 10^5.
Output
For each test case, output two lines:
* on the first line output n integers — lexicographically minimal permutation that could have been originally presented to Polycarp;
* on the second line print n integers — lexicographically maximal permutation that could have been originally presented to Polycarp;
Example
Input
4
7
3 3 4 4 7 7 7
4
1 2 3 4
7
3 4 5 5 5 7 7
1
1
Output
3 1 4 2 7 5 6
3 2 4 1 7 6 5
1 2 3 4
1 2 3 4
3 4 5 1 2 7 6
3 4 5 2 1 7 6
1
1
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
s = set()
e = set()
for i in l:
if i in s:
continue
s.add(i)
for i in range(1,n+1):
if i in s:
continue
e.add(i)
a = list(e)
a.sort(reverse = True)
am = [0]*n
ind = -1
for i in range(n):
x = l[i]
if x in s:
am[i] = x
if len(s) == 1:
ind = i
s.remove(x)
else:
am[i] = a.pop()
# aux = am[ind+1:]
# ama = am[0:ind+1]+aux[::-1]
ama = [0]*n
i = 0
while i < n:
j = i
while j < n:
if l[j] == l[i]:
pass
else:
break
j = j+1
w = j
ama[i] = am[i]
k = i+1
j -= 1
while k < w:
ama[k] = am[j]
j -= 1
k += 1
i = w
print(*am)
print(*ama)
``` | instruction | 0 | 16,225 | 12 | 32,450 |
No | output | 1 | 16,225 | 12 | 32,451 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,265 | 12 | 32,530 |
Tags: brute force, implementation
Correct Solution:
```
import itertools
import functools
def allSubArrays(xs):
n = len(xs)
indices = list(range(n+1))
for i,j in itertools.combinations(indices,2):
yield xs[i:j]
n=int(input())
my_list=list(map(int,input().split(" ")))
list_=list(allSubArrays(my_list))
for i in range(len(list_)):
list_[i]=functools.reduce(lambda x,y:x^y,list_[i])
print(max(list_))
``` | output | 1 | 16,265 | 12 | 32,531 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,266 | 12 | 32,532 |
Tags: brute force, implementation
Correct Solution:
```
import math,sys
from collections import defaultdict,deque
import bisect as bi
def yes():print('YES')
def no():print('NO')
def I():return (int(sys.stdin.readline()))
def In():return(map(int,sys.stdin.readline().split()))
def Sn():return sys.stdin.readline().strip()
def Pr(x): sys.stdout.write(str(x)+'\n')
#sys.setrecursionlimit(1500)
def dict(a):
d={}
for x in a:
if d.get(x,-1)!=-1:
d[x]+=1
else:
d[x]=1
return d
# Find leftmost value >= x #
def find_gte(a, x):
i = bi.bisect_left(a, x)
if i != len(a):
return i
else:
return -1
def main():
try:
ans=0
n=I()
l=list(In())
for i in range(n):
cnt=l[i]
ans=max(cnt,ans)
for j in range(i+1,n):
cnt^=l[j]
ans=max(cnt,ans)
print(ans)
except:
pass
M = 998244353
P = 1000000007
if __name__ == '__main__':
# for _ in range(I()):main()
for _ in range(1):main()
#End#
# ******************* All The Best ******************* #
``` | output | 1 | 16,266 | 12 | 32,533 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,267 | 12 | 32,534 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
res = 0
for i in range(n):
x = 0
for j in range(i, n):
x = (x ^ a[j])
res = max(res, x)
print(res)
``` | output | 1 | 16,267 | 12 | 32,535 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,268 | 12 | 32,536 |
Tags: brute force, implementation
Correct Solution:
```
#from dust i have come, dust i will be
n=int(input())
a=list(map(int,input().split()))
m=a[0]
for i in range(len(a)-1):
x=a[i]
m=max(m,x)
for j in range(i+1,len(a)):
x=x^a[j]
m=max(m,x)
print(max(m,max(a)))
``` | output | 1 | 16,268 | 12 | 32,537 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,269 | 12 | 32,538 |
Tags: brute force, implementation
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
pre=[0]*(n+1)
for i in range(1,n+1):
pre[i]=pre[i-1]^l[i-1]
ans=[]
for i in range(n+1):
for j in range(n+1):
ans.append(pre[j]^pre[i])
print(max(ans))
``` | output | 1 | 16,269 | 12 | 32,539 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,270 | 12 | 32,540 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
s = input().split()
s = [int(x) for x in s]
m = 0
for i in range(n):
xor = s[i]
if xor > m:
m = xor
for j in range(i+1,n):
xor = xor ^ s[j]
if xor > m:
m=xor
print(m)
``` | output | 1 | 16,270 | 12 | 32,541 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,271 | 12 | 32,542 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
def xor(s):
x = 0
for i in s:
x ^= i
return x
mx = -1
for i in range(n):
for j in range(n):
if i == j:
if a[i] > mx:
mx = a[i]
else:
x = xor(a[i:j+1])
if x > mx:
mx = x
print(mx)
``` | output | 1 | 16,271 | 12 | 32,543 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three). | instruction | 0 | 16,272 | 12 | 32,544 |
Tags: brute force, implementation
Correct Solution:
```
n = int(input())
ls = list(map(int, input().split()))
mx = 0
for i in range(n):
curr = ls[i]
mx = max(curr, mx)
for j in range(i + 1, n):
curr ^= ls[j]
mx = max(curr, mx)
print(mx)
``` | output | 1 | 16,272 | 12 | 32,545 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
from itertools import accumulate
from operator import xor
n = int(input())
A = [0] + list(accumulate(map(int, input().split()), xor))
print(max(A[i]^A[j] for i in range(n+1) for j in range(i+1,n+1)))
``` | instruction | 0 | 16,273 | 12 | 32,546 |
Yes | output | 1 | 16,273 | 12 | 32,547 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
n = input()
lst = [int(x) for x in input().split(" ")]
res = []
for i,l in enumerate(lst):
res.append(l)
for j in range(i+1,len(lst)):
l ^= lst[j]
res.append(l)
print(max(res))
``` | instruction | 0 | 16,274 | 12 | 32,548 |
Yes | output | 1 | 16,274 | 12 | 32,549 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
n = int(input())
l = list(map(int, input().split()))
ans = 0
for i in range(n):
t = l[i]
for j in range(i + 1, n):
ans = max(ans, t)
t ^= l[j]
ans = max(ans, t)
print(max(ans, l[n - 1]))
``` | instruction | 0 | 16,275 | 12 | 32,550 |
Yes | output | 1 | 16,275 | 12 | 32,551 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
ans=0
k=max(a)
for i in range(n-1):
tmp=a[i]
for j in range(i+1,n):
tmp^=a[j]
ans=max(ans,tmp)
print(max(ans,k))
``` | instruction | 0 | 16,276 | 12 | 32,552 |
Yes | output | 1 | 16,276 | 12 | 32,553 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
input()
a = list(map(int, input().split()))
nitest = 0
for i in range(len(a)):
xor = 0
for j in range(i, len(a)):
xor ^= a[j]
nitest = max(nitest, xor)
print(nitest)
``` | instruction | 0 | 16,277 | 12 | 32,554 |
No | output | 1 | 16,277 | 12 | 32,555 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
import math
for i in range(1):
n=int(input())
l=list(map(int,input().split()))
ans=0
for i in range(n):
c=0
for j in range(i,n):
c=c^l[j]
ans=max(ans,c)
print(ans)
``` | instruction | 0 | 16,278 | 12 | 32,556 |
No | output | 1 | 16,278 | 12 | 32,557 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
n=int(input())
li=list(map(int,input().split()))
temp=0
for i in range(n):
xor=0
for j in range(i,n):
if xor^li[j]>xor:
xor=xor^li[j]
else:
break
if xor>temp:
temp=xor
print(temp)
``` | instruction | 0 | 16,279 | 12 | 32,558 |
No | output | 1 | 16,279 | 12 | 32,559 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Little Petya likes arrays that consist of non-negative integers a lot. Recently his mom has presented him one such array consisting of n elements. Petya immediately decided to find there a segment of consecutive elements, such that the xor of all numbers from this segment was maximal possible. Help him with that.
The xor operation is the bitwise exclusive "OR", that is denoted as "xor" in Pascal and "^" in C/C++/Java.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the number of elements in the array. The second line contains the space-separated integers from the array. All numbers are non-negative integers strictly less than 230.
Output
Print a single integer — the required maximal xor of a segment of consecutive elements.
Examples
Input
5
1 2 1 1 2
Output
3
Input
3
1 2 7
Output
7
Input
4
4 2 4 8
Output
14
Note
In the first sample one of the optimal segments is the segment that consists of the first and the second array elements, if we consider the array elements indexed starting from one.
The second sample contains only one optimal segment, which contains exactly one array element (element with index three).
Submitted Solution:
```
n=int(input())
a=input().split()
xor=0
ans=int(a[0])
for i in range(n):
for j in range(i,n):
ans=int(a[i])
for k in range(i+1,j+1):
ans=ans^int(a[k])
if(ans>=xor):
xor=ans
print(xor)
``` | instruction | 0 | 16,280 | 12 | 32,560 |
No | output | 1 | 16,280 | 12 | 32,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,293 | 12 | 32,586 |
Tags: greedy, implementation, math
Correct Solution:
```
def main():
n, k = map(int, input().split())
arr = list(map(int, input().split()))
got = [0]*(k+1)
for i in range(0, k):
for j in range(n//k):
if arr[j*k+i]==1:
got[i] += 1
answer = 0
for i in range(k):
answer += min(got[i], n//k-got[i])
print(answer)
main()
``` | output | 1 | 16,293 | 12 | 32,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,294 | 12 | 32,588 |
Tags: greedy, implementation, math
Correct Solution:
```
n, k = map(int, input().split())
a = input().split()
res = 0
for i in range(k):
one = 0; two = 0
for j in range(i, n, k):
if a[j] == '2': two+= 1
else: one+= 1
res+= min(one, two)
print(res)
``` | output | 1 | 16,294 | 12 | 32,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,295 | 12 | 32,590 |
Tags: greedy, implementation, math
Correct Solution:
```
n, k = map(int, input().split())
l = list(map(int, input().split()))
ans = 0
z = n // k
for i in range(k):
b = l[i::k]
co = b.count(1)
ans += min(z - co, co)
print(ans)
``` | output | 1 | 16,295 | 12 | 32,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,296 | 12 | 32,592 |
Tags: greedy, implementation, math
Correct Solution:
```
R = lambda: map(int, input().split())
n, k = R()
a = list(R())
print(sum(min(x.count(1), x.count(2)) for x in (a[i::k] for i in range(k))))
``` | output | 1 | 16,296 | 12 | 32,593 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,297 | 12 | 32,594 |
Tags: greedy, implementation, math
Correct Solution:
```
import math
n,k=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in range(k):
r=a[i];m=0
for j in range(n//k):
if a[i+j*k]!=r:
m+=1
ans+=min(m,n//k-m)
print(ans)
``` | output | 1 | 16,297 | 12 | 32,595 |
Provide tags and a correct Python 3 solution for this coding contest problem.
This task will exclusively concentrate only on the arrays where all elements equal 1 and/or 2.
Array a is k-period if its length is divisible by k and there is such array b of length k, that a is represented by array b written exactly <image> times consecutively. In other words, array a is k-periodic, if it has period of length k.
For example, any array is n-periodic, where n is the array length. Array [2, 1, 2, 1, 2, 1] is at the same time 2-periodic and 6-periodic and array [1, 2, 1, 1, 2, 1, 1, 2, 1] is at the same time 3-periodic and 9-periodic.
For the given array a, consisting only of numbers one and two, find the minimum number of elements to change to make the array k-periodic. If the array already is k-periodic, then the required value equals 0.
Input
The first line of the input contains a pair of integers n, k (1 ≤ k ≤ n ≤ 100), where n is the length of the array and the value n is divisible by k. The second line contains the sequence of elements of the given array a1, a2, ..., an (1 ≤ ai ≤ 2), ai is the i-th element of the array.
Output
Print the minimum number of array elements we need to change to make the array k-periodic. If the array already is k-periodic, then print 0.
Examples
Input
6 2
2 1 2 2 2 1
Output
1
Input
8 4
1 1 2 1 1 1 2 1
Output
0
Input
9 3
2 1 1 1 2 1 1 1 2
Output
3
Note
In the first sample it is enough to change the fourth element from 2 to 1, then the array changes to [2, 1, 2, 1, 2, 1].
In the second sample, the given array already is 4-periodic.
In the third sample it is enough to replace each occurrence of number two by number one. In this case the array will look as [1, 1, 1, 1, 1, 1, 1, 1, 1] — this array is simultaneously 1-, 3- and 9-periodic. | instruction | 0 | 16,298 | 12 | 32,596 |
Tags: greedy, implementation, math
Correct Solution:
```
n, m = map(int, input().split())
arr = list(map(int, input().split()))
cnt1, cnt2 = [0] * (m+1), [0] * (m+1)
for i in range(len(arr)):
if arr[i] == 1:
cnt1[i % m + 1] += 1
if arr[i] == 2:
cnt2[i % m + 1] += 1
res = 0
for i in range(m+1):
res += min(cnt1[i], cnt2[i])
print(res)
``` | output | 1 | 16,298 | 12 | 32,597 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.