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 |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
The only difference between problems C1 and C2 is that all values in input of problem C1 are distinct (this condition may be false for problem C2).
You are given a sequence a consisting of n integers.
You are making a sequence of moves. During each move you must take either the leftmost element of the sequence or the rightmost element of the sequence, write it down and remove it from the sequence. Your task is to write down a strictly increasing sequence, and among all such sequences you should take the longest (the length of the sequence is the number of elements in it).
For example, for the sequence [1, 2, 4, 3, 2] the answer is 4 (you take 1 and the sequence becomes [2, 4, 3, 2], then you take the rightmost element 2 and the sequence becomes [2, 4, 3], then you take 3 and the sequence becomes [2, 4] and then you take 4 and the sequence becomes [2], the obtained increasing sequence is [1, 2, 3, 4]).
Input
The first line of the input contains one integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of elements in a.
The second line of the input contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 2 ⋅ 10^5), where a_i is the i-th element of a.
Output
In the first line of the output print k — the maximum number of elements in a strictly increasing sequence you can obtain.
In the second line print a string s of length k, where the j-th character of this string s_j should be 'L' if you take the leftmost element during the j-th move and 'R' otherwise. If there are multiple answers, you can print any.
Examples
Input
5
1 2 4 3 2
Output
4
LRRR
Input
7
1 3 5 6 5 4 2
Output
6
LRLRRR
Input
3
2 2 2
Output
1
R
Input
4
1 2 4 3
Output
4
LLRR
Note
The first example is described in the problem statement.
Submitted Solution:
```
def f(r1, l):
global r, lastNum, lPos, rPos
for i in range(l):
r.append(r1)
if r1 == 'L':
lastNum = a[lPos]
lPos += 1
rPos += level - 1
else:
lastNum = a[rPos]
rPos -= 1
lPos -= level - 1
n = int(input())
a = list(map(int, input().split()))
r = []
lastNum = -1
lPos = 0
rPos = n-1
level = 1
while lPos < rPos:
if a[lPos] == a[rPos]:
level += 1
lPos += 1
rPos -= 1
continue
if a[lPos] < a[rPos] and a[lPos] > lastNum:
f('L', level)
level = 1
continue
if a[lPos] < a[rPos] and a[lPos] <= lastNum and a[rPos] > lastNum:
f('R', level)
level = 1
continue
if a[lPos] > a[rPos] and a[rPos] > lastNum:
f('R', level)
level = 1
continue
if a[lPos] > a[rPos] and a[rPos] <= lastNum and a[lPos] > lastNum:
f('L', level)
level = 1
continue
if a[lPos] < lastNum and a[rPos] < lastNum:
break
if lPos >= rPos and a[lPos]> lastNum:
f('L', level)
print(len(r))
print(*r, sep='')
#1 2 4 3 2
``` | instruction | 0 | 6,642 | 12 | 13,284 |
No | output | 1 | 6,642 | 12 | 13,285 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,645 | 12 | 13,290 |
Tags: sortings, two pointers
Correct Solution:
```
n, I = [int(x) for x in input().split()]
d = pow(2, (8 * I // n))
a = [int(x) for x in input().split()]
a.sort()
val = [0]
m = 0
for i in range(1, n):
if a[i - 1] != a[i]:
val.append(i)
diff = len(val) - d
if len(val) <= d:
print("0")
else:
for i in range(diff):
m = max(val[i + d] - val[i], m)
print(n - m)
``` | output | 1 | 6,645 | 12 | 13,291 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,646 | 12 | 13,292 |
Tags: sortings, two pointers
Correct Solution:
```
from itertools import groupby
def mp3(n, I, a):
k = int((I * 8) / n)
d = 1 << k
c = [len(list(group)) for (key, group) in groupby(sorted(a))]
chgs = sum(c[d:])
ans = chgs
for i in range(0, len(c) - d):
chgs += c[i]
chgs -= c[i + d]
ans = min(ans, chgs)
return ans
if __name__ == "__main__":
nn, II = list(map(int, input().split()))
aa = list(map(int, input().split()))
print(mp3(nn, II, aa))
``` | output | 1 | 6,646 | 12 | 13,293 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,647 | 12 | 13,294 |
Tags: sortings, two pointers
Correct Solution:
```
n, I = map(int, input().split())
a = sorted(list(map(int, input().split())))
cur = 0
b = [0]
for i in range(1, n):
if a[i] != a[i - 1]:
cur += 1
b.append(cur)
r = 1
ans = int(1e18)
for l in range(len(b)):
ma = b[l] + 2 ** min((I * 8 // n), 30) - 1
while r < n and b[r] <= ma:
r += 1
ans = min(ans, l + (n - r))
print(ans)
``` | output | 1 | 6,647 | 12 | 13,295 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,648 | 12 | 13,296 |
Tags: sortings, two pointers
Correct Solution:
```
n,m=map(int,input().split())
a=list(map(int,input().split()))
m*=8
m=m//n
m=2**m
#print(m)
d={}
for i in a:
try:
d[i]+=1
except:
d[i]=1
#a=sorted(list(set(a)))
a.sort()
val=[0]
mx=0
for i in range(1, n):
if a[i - 1]!=a[i]:
val.append(i)
diff=len(val)-m
if len(val)<=m:
print(0)
else:
for i in range(diff):
mx=max(val[i+m]-val[i],mx)
print(n-mx)
``` | output | 1 | 6,648 | 12 | 13,297 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,649 | 12 | 13,298 |
Tags: sortings, two pointers
Correct Solution:
```
R=lambda:map(int,input().split())
n,I=R()
a=sorted(R())
b=[0]+[i+1for i in range(n-1)if a[i]<a[i+1]]
print(n-max((y-x for x,y in zip(b,b[1<<8*I//n:])),default=n))
``` | output | 1 | 6,649 | 12 | 13,299 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,650 | 12 | 13,300 |
Tags: sortings, two pointers
Correct Solution:
```
from math import log2, ceil
n, k = map(int, input().split())
k *= 8
a = sorted(list(map(int, input().split())))
q1, dif = 0, 1
ans = float('inf')
for q in range(n):
while n*ceil(log2(dif)) <= k and q1 < n:
if q1 == n-1 or a[q1] != a[q1+1]:
dif += 1
q1 += 1
ans = min(ans, q+n-q1)
if q != n-1 and a[q] != a[q+1]:
dif -= 1
print(ans)
``` | output | 1 | 6,650 | 12 | 13,301 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,651 | 12 | 13,302 |
Tags: sortings, two pointers
Correct Solution:
```
#!/usr/bin/env python
import os
import sys
from io import BytesIO, IOBase
import math
from collections import Counter
def main():
n, I = map(int, input().split())
a = list(map(int, input().split()))
k = pow(2, 8 * I // n)
b = [0]
a.sort()
for i in range(1, n):
if a[i] != a[i-1]:
b.append(i)
if k >= len(b):
print(0)
else:
m = 0
for i in range(len(b) - k):
m = max(m, b[i+k] - b[i])
print(n - m)
# 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 | 6,651 | 12 | 13,303 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One common way of digitalizing sound is to record sound intensity at particular time moments. For each time moment intensity is recorded as a non-negative integer. Thus we can represent a sound file as an array of n non-negative integers.
If there are exactly K distinct values in the array, then we need k = ⌈ log_{2} K ⌉ bits to store each value. It then takes nk bits to store the whole file.
To reduce the memory consumption we need to apply some compression. One common way is to reduce the number of possible intensity values. We choose two integers l ≤ r, and after that all intensity values are changed in the following way: if the intensity value is within the range [l;r], we don't change it. If it is less than l, we change it to l; if it is greater than r, we change it to r. You can see that we lose some low and some high intensities.
Your task is to apply this compression in such a way that the file fits onto a disk of size I bytes, and the number of changed elements in the array is minimal possible.
We remind you that 1 byte contains 8 bits.
k = ⌈ log_{2} K ⌉ is the smallest integer such that K ≤ 2^{k}. In particular, if K = 1, then k = 0.
Input
The first line contains two integers n and I (1 ≤ n ≤ 4 ⋅ 10^{5}, 1 ≤ I ≤ 10^{8}) — the length of the array and the size of the disk in bytes, respectively.
The next line contains n integers a_{i} (0 ≤ a_{i} ≤ 10^{9}) — the array denoting the sound file.
Output
Print a single integer — the minimal possible number of changed elements.
Examples
Input
6 1
2 1 2 3 4 3
Output
2
Input
6 2
2 1 2 3 4 3
Output
0
Input
6 1
1 1 2 2 3 3
Output
2
Note
In the first example we can choose l=2, r=3. The array becomes 2 2 2 3 3 3, the number of distinct elements is K=2, and the sound file fits onto the disk. Only two values are changed.
In the second example the disk is larger, so the initial file fits it and no changes are required.
In the third example we have to change both 1s or both 3s. | instruction | 0 | 6,652 | 12 | 13,304 |
Tags: sortings, two pointers
Correct Solution:
```
n,I=map(int,input().split())
#print(n,I)
a=list(map(int,input().split()))
I*=8
k=I//n
if k>=20:
res=0
else:
K=2**k
#print(K,I)
cc={}
for ai in a:
cc[ai]=cc.get(ai,0)+1
pres=[]
dd=sorted(cc)
for i in dd:
pres.append(cc[i])
for i in range(1,len(pres)):
pres[i]+=pres[i-1]
if K>=len(pres):
res=0
else:
mm=0
for i in range(K,len(pres)):
if mm<pres[i]-pres[i-K]:
mm=pres[i]-pres[i-K]
res=n-mm
print(res)
``` | output | 1 | 6,652 | 12 | 13,305 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,720 | 12 | 13,440 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import io
import os
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
DEBUG = False
def solveBrute(N, A):
ans = 0
for i in range(N):
for j in range(i + 1, N):
ans ^= A[i] + A[j]
return ans
def solve(N, A):
B = max(A).bit_length()
ans = 0
for k in range(B + 1):
# Count number of pairs with kth bit on (0 indexed)
# For example if k==2, want pairs where lower 3 bits are between 100 and 111 inclusive
# If we mask A to the lower 3 bits, we can find all pairs that sum to either 100 to 111 or overflowed to 1100 to 1111
MOD = 1 << (k + 1)
MASK = MOD - 1
# Sort by x & MASK incrementally
left = []
right = []
for x in A:
if (x >> k) & 1:
right.append(x)
else:
left.append(x)
A = left + right
arr = [x & MASK for x in A]
if DEBUG:
assert arr == sorted(arr)
numPairs = 0
tLo = 1 << k
tHi = (1 << (k + 1)) - 1
for targetLo, targetHi in [(tLo, tHi), (MOD + tLo, MOD + tHi)]:
# Want to binary search for y such that targetLo <= x + y <= targetHi
# But this TLE so walk the lo/hi pointers instead
lo = N
hi = N
for i, x in enumerate(arr):
lo = max(lo, i + 1)
hi = max(hi, lo)
while lo - 1 >= i + 1 and arr[lo - 1] >= targetLo - x:
lo -= 1
while hi - 1 >= lo and arr[hi - 1] > targetHi - x:
hi -= 1
numPairs += hi - lo
if DEBUG:
# Check
assert lo == bisect_left(arr, targetLo - x, i + 1)
assert hi == bisect_right(arr, targetHi - x, lo)
for j, y in enumerate(arr):
cond = i < j and targetLo <= x + y <= targetHi
if lo <= j < hi:
assert cond
else:
assert not cond
ans += (numPairs % 2) << k
return ans
if DEBUG:
import random
random.seed(0)
for i in range(100):
A = [random.randint(1, 1000) for i in range(100)]
N = len(A)
ans1 = solveBrute(N, A)
ans2 = solve(N, A)
print(A, bin(ans1), bin(ans2))
assert ans1 == ans2
else:
if False:
# Timing
import random
random.seed(0)
A = [random.randint(1, 10 ** 7) for i in range(400000)]
N = len(A)
print(solve(N, A))
if __name__ == "__main__":
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = solve(N, A)
print(ans)
``` | output | 1 | 6,720 | 12 | 13,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,721 | 12 | 13,442 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import io
import os
from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
DEBUG = False
def solveBrute(N, A):
ans = 0
for i in range(N):
for j in range(i + 1, N):
ans ^= A[i] + A[j]
return ans
def solve(N, A):
B = max(A).bit_length()
ans = 0
for k in range(B + 1):
# Count number of pairs with kth bit on (0 indexed)
# For example if k==2, want pairs where lower 3 bits are between 100 and 111 inclusive
# If we mask A to the lower 3 bits, we can find all pairs that sum to either 100 to 111 or overflowed to 1100 to 1111
MOD = 1 << (k + 1)
MASK = MOD - 1
# Sort by x & MASK incrementally
i = 0
right = []
for x in A:
if (x >> k) & 1:
right.append(x)
else:
A[i] = x
i += 1
assert N - i == len(right)
A[i:] = right
arr = [x & MASK for x in A]
if DEBUG:
assert arr == sorted(arr)
numPairs = 0
tlo = 1 << k
thi = (1 << (k + 1)) - 1
for targetLo, targetHi in [(tlo, thi), (MOD + tlo, MOD + thi)]:
# Want to binary search for y such that targetLo <= x + y <= targetHi
# But this TLE so walk the lo/hi pointers instead
lo = N
hi = N
for i, x in enumerate(arr):
lo = max(lo, i + 1)
hi = max(hi, lo)
while lo - 1 >= i + 1 and arr[lo - 1] >= targetLo - x:
lo -= 1
while hi - 1 >= lo and arr[hi - 1] >= targetHi - x + 1:
hi -= 1
numPairs += hi - lo
if DEBUG:
assert lo == bisect_left(arr, targetLo - x, i + 1)
assert hi == bisect_right(arr, targetHi - x, lo)
# Check
for j, y in enumerate(arr):
cond = i < j and targetLo <= x + y <= targetHi
if lo <= j < hi:
assert cond
else:
assert not cond
ans += (numPairs % 2) << k
return ans
if DEBUG:
import random
random.seed(0)
for i in range(100):
A = [random.randint(1, 1000) for i in range(100)]
N = len(A)
ans1 = solveBrute(N, A)
ans2 = solve(N, A)
print(A, bin(ans1), bin(ans2))
assert ans1 == ans2
else:
if False:
# Timing
import random
random.seed(0)
A = [random.randint(1, 10 ** 7) for i in range(400000)]
N = len(A)
print(solve(N, A))
if __name__ == "__main__":
(N,) = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = solve(N, A)
print(ans)
``` | output | 1 | 6,721 | 12 | 13,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,722 | 12 | 13,444 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import math
input_list = lambda: list(map(int, input().split()))
def main():
n = int(input())
a = input_list()
temp = []
ans = 0
for bit in range(26):
temp.clear()
value1 = 2**bit
value2 = 2**(bit + 1) - 1
value3 = 2**(bit + 1) + 2**bit
value4 = 2**(bit + 2) - 1
for i in range(n):
temp.append(a[i]%(2**(bit+1)))
f1, l1, f2, l2 = [n-1, n-1, n-1, n-1]
temp.sort()
noOfOnes = 0
for i in range(n):
while f1>=0 and temp[f1]+temp[i]>=value1:
f1 = f1 - 1
while l1>=0 and temp[l1] + temp[i]>value2:
l1 = l1 - 1
while f2>=0 and temp[f2] + temp[i]>=value3 :
f2 = f2 - 1
while l2>=0 and temp[l2] + temp[i]>value4:
l2 = l2 - 1
noOfOnes = noOfOnes + max(0, l1 - max(i,f1))
noOfOnes = noOfOnes + max(0, l2 - max(i, f2))
if noOfOnes%2==1:
ans = ans + 2**bit
print(ans)
main()
``` | output | 1 | 6,722 | 12 | 13,445 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,723 | 12 | 13,446 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import math
import sys
input = sys.stdin.readline
input_list = lambda: list(map(int, input().split()))
def main():
n = int(input())
a = input_list()
temp = []
ans = 0
for bit in range(26):
temp.clear()
value1 = 2**bit
value2 = 2**(bit + 1) - 1
value3 = 2**(bit + 1) + 2**bit
value4 = 2**(bit + 2) - 1
for i in range(n):
temp.append(a[i]%(2**(bit+1)))
f1, l1, f2, l2 = [n-1, n-1, n-1, n-1]
temp.sort()
noOfOnes = 0
for i in range(n):
while f1>=0 and temp[f1]+temp[i]>=value1:
f1 = f1 - 1
while l1>=0 and temp[l1] + temp[i]>value2:
l1 = l1 - 1
while f2>=0 and temp[f2] + temp[i]>=value3 :
f2 = f2 - 1
while l2>=0 and temp[l2] + temp[i]>value4:
l2 = l2 - 1
noOfOnes = noOfOnes + max(0, l1 - max(i,f1))
noOfOnes = noOfOnes + max(0, l2 - max(i, f2))
if noOfOnes%2==1:
ans = ans + 2**bit
print(ans)
main()
``` | output | 1 | 6,723 | 12 | 13,447 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,724 | 12 | 13,448 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
n = int(input())
a = sorted(map(int, input().split()))
ans = 0
for d in range(25, -1, -1):
bit = 1 << d
cnt = 0
j = k = l = n - 1
for i, x in enumerate(a):
j, k, l = max(j, i), max(k, i), max(l, i)
while i < j and a[j] >= bit - x:
j -= 1
while j < k and a[k] >= 2 * bit - x:
k -= 1
while k < l and a[l] >= 3 * bit - x:
l -= 1
cnt += k - j + n - 1 - l
if cnt & 1:
ans += bit
for i in range(n):
a[i] &= ~bit
a.sort()
print(ans)
if __name__ == '__main__':
main()
``` | output | 1 | 6,724 | 12 | 13,449 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2. | instruction | 0 | 6,725 | 12 | 13,450 |
Tags: binary search, bitmasks, constructive algorithms, data structures, math, sortings
Correct Solution:
```
from bisect import bisect_left, bisect_right
def go():
n = int(input())
a = list(map(int, input().split()))
b = max(a).bit_length()
res = 0
vals = a
for i in range(b + 1):
# print("")
b2 = 2 << i
b1 = 1 << i
a0 = [aa for aa in a if aa & b1==0]
a1 = [aa for aa in a if aa & b1]
a = a0 + a1
vals = [aa % b2 for aa in a]
cnt = 0
# vals = sorted(aa % b2 for aa in a)
x1, x2, y1 = n - 1, n - 1, n - 1
for j, v in enumerate(vals):
while x1 > -1 and vals[x1] >= b1 - v:
x1 -= 1
while y1 > -1 and vals[y1] > b2 - v - 1:
y1 -= 1
# x, y = bisect_left(vals,b1-v), bisect_right(vals,b2-v-1)
x, y = x1 + 1, y1 + 1
# print('+++', x, y, bisect_left(vals, b1 - v), bisect_right(vals, b2 - v - 1))
cnt += y - x
if x <= j < y:
cnt -= 1
while x2 > -1 and vals[x2] >= b2 + b1 - v:
x2 -= 1
# x, y = bisect_left(vals,b2+b1-v), len(vals)
x, y = x2 + 1, n
# print('---', x, y, bisect_left(vals, b2 + b1 - v), len(vals))
cnt += y - x
if x <= j < y:
cnt -= 1
res += b1 * (cnt // 2 % 2)
return res
print(go())
``` | output | 1 | 6,725 | 12 | 13,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
import sys
from array import array # noqa: F401
from typing import List, Tuple, TypeVar, Generic, Sequence, Union # noqa: F401
def input():
return sys.stdin.buffer.readline().decode('utf-8')
def main():
n = int(input())
a = sorted(map(int, input().split()))
ans = 0
for d in range(23, -1, -1):
bit = 1 << d
cnt = 0
j = k = l = n - 1
for i, x in enumerate(a):
j, k, l = max(j, i), max(k, i), max(l, i)
while i < j and a[j] >= bit - x:
j -= 1
while j < k and a[k] >= 2 * bit - x:
k -= 1
while k < l and a[l] >= 3 * bit - x:
l -= 1
cnt += k - j + n - 1 - l
if cnt & 1:
ans += bit
for i in range(n):
a[i] &= ~bit
a.sort()
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 6,726 | 12 | 13,452 |
No | output | 1 | 6,726 | 12 | 13,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
def go():
n = int(input())
a = list(map(int, input().split()))
b = max(a).bit_length()
res = 0
for i in range(b+1):
b2 = 2 << i
b1 = 1 << i
cnt = 0
vals = sorted(list(aa % b2 for aa in a))
x, y = n - 1, n - 1
for j, v in enumerate(vals):
while x >= 0 and vals[x] >= b1 - v:
x -= 1
while y >= 0 and vals[y] > b2 - 1 - v:
y -= 1
# print(x, y)
if y <= j:
break
cnt += y - max(x, 0, j)
# cnt += sum(1 for vv in vals[j + 1:] if b1 - v <= vv <= b2 - 1 - v)
res += b1 * (cnt % 2)
return res
print(go())
``` | instruction | 0 | 6,727 | 12 | 13,454 |
No | output | 1 | 6,727 | 12 | 13,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
def go():
n = int(input())
a = list(map(int, input().split()))
b = max(a).bit_length()
res = 0
for i in range(b):
b2 = 2 << i
b1 = 1 << i
cnt = 0
vals = sorted(list(aa % b2 for aa in a))
x, y = n - 1, n - 1
for j, v in enumerate(vals):
while x >= 0 and vals[x] >= b1 - v:
x -= 1
while y >= 0 and vals[y] > b2 - 1 - v:
y -= 1
# print(x, y)
if y<=j:
break
cnt += y-max(x, 0, j)
# cnt += sum(1 for vv in vals[j + 1:] if b1 - v <= vv <= b2 - 1 - v)
res += b1 * (cnt % 2)
return res
print(go())
``` | instruction | 0 | 6,728 | 12 | 13,456 |
No | output | 1 | 6,728 | 12 | 13,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Catherine received an array of integers as a gift for March 8. Eventually she grew bored with it, and she started calculated various useless characteristics for it. She succeeded to do it for each one she came up with. But when she came up with another one — xor of all pairwise sums of elements in the array, she realized that she couldn't compute it for a very large array, thus she asked for your help. Can you do it? Formally, you need to compute
$$$ (a_1 + a_2) ⊕ (a_1 + a_3) ⊕ … ⊕ (a_1 + a_n) \\\ ⊕ (a_2 + a_3) ⊕ … ⊕ (a_2 + a_n) \\\ … \\\ ⊕ (a_{n-1} + a_n) \\\ $$$
Here x ⊕ y is a bitwise XOR operation (i.e. x ^ y in many modern programming languages). You can read about it in Wikipedia: <https://en.wikipedia.org/wiki/Exclusive_or#Bitwise_operation>.
Input
The first line contains a single integer n (2 ≤ n ≤ 400 000) — the number of integers in the array.
The second line contains integers a_1, a_2, …, a_n (1 ≤ a_i ≤ 10^7).
Output
Print a single integer — xor of all pairwise sums of integers in the given array.
Examples
Input
2
1 2
Output
3
Input
3
1 2 3
Output
2
Note
In the first sample case there is only one sum 1 + 2 = 3.
In the second sample case there are three sums: 1 + 2 = 3, 1 + 3 = 4, 2 + 3 = 5. In binary they are represented as 011_2 ⊕ 100_2 ⊕ 101_2 = 010_2, thus the answer is 2.
⊕ is the bitwise xor operation. To define x ⊕ y, consider binary representations of integers x and y. We put the i-th bit of the result to be 1 when exactly one of the i-th bits of x and y is 1. Otherwise, the i-th bit of the result is put to be 0. For example, 0101_2 ⊕ 0011_2 = 0110_2.
Submitted Solution:
```
import math
input_list = lambda: list(map(int, input().split()))
def main():
n = int(input())
a = input_list()
temp = []
ans = 0
for bit in range(26):
temp.clear()
noOfOnes = 0
value1 = 2**bit
value2 = 2**(bit + 1) - 1
value3 = 2**(bit + 1) + 2**bit
value4 = 2**(bit + 2) - 1
for i in range(n):
temp.append(a[i]%(2**(bit+1)))
f1, l1, f2, l2 = [1, n-1, 1, n-1]
temp.sort()
for i in range(n):
while f1<=n-1 and temp[f1]+temp[i]<value1:
f1 = f1 + 1
while l1>=0 and temp[l1] + temp[i]>value2:
l1 = l1 - 1
while f2<=n-1 and temp[f2] + temp[i]<value3 :
f2 = f2 + 1
while l2>=0 and temp[l2] + temp[i]>value4:
l2 = l2 - 1
noOfOnes = noOfOnes + max(0, l1 - max(i+1,f1) + 1)
noOfOnes = noOfOnes + max(0, l2 - max(i+1, f2) + 1)
if noOfOnes%2==1:
ans = ans + 2**bit
print(ans)
main()
``` | instruction | 0 | 6,729 | 12 | 13,458 |
No | output | 1 | 6,729 | 12 | 13,459 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,746 | 12 | 13,492 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
import sys
N = int(input())
a = [int(x) for x in input().split(' ')]
b = [0 for _ in range(N)]
st = []
for i, x in enumerate(a):
dif = a[i] - a[i-1] if i != 0 else a[i]
if dif:
if len(st) + 1 < dif:
print(-1)
sys.exit(0)
else:
b[i] = a[i-1] if i != 0 else 0
for j in range(dif-1):
b[st.pop()] = a[i-1] + j + 1
else:
st.append(i)
for x in st:
b[x] = a[-1] + 1
print(' '.join(map(str, b)))
``` | output | 1 | 6,746 | 12 | 13,493 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,747 | 12 | 13,494 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
# avoiding using queue
def main():
test = 1
for _ in range(test):
n = int(input())
ara = [int(num) for num in input().split()]
mark = [True for _ in range(n + 1)]
for num in ara:
mark[num] = False
take_from = []
for index in range(n + 1):
if mark[index]:
take_from.append(index)
ans = []
ans.append(take_from[0])
take_at = 1
take_size = len(take_from)
for index in range(1, n):
if ara[index] != ara[index - 1]:
ans.append(ara[index - 1])
elif take_at < take_size:
ans.append(take_from[take_at])
take_at += 1
else:
ans.append(n + 1)
ans = ' '.join(map(str, ans))
print(ans)
if __name__ == "__main__":
main()
``` | output | 1 | 6,747 | 12 | 13,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,748 | 12 | 13,496 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
""" Python 3 compatibility tools. """
from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
input = raw_input
range = xrange
filter = itertools.ifilter
map = itertools.imap
zip = itertools.izip
def is_it_local():
script_dir = str(os.getcwd()).split('/')
username = "dipta007"
return username in script_dir
def READ(fileName):
if is_it_local():
sys.stdin = open(f'./{fileName}', 'r')
# 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")
if not is_it_local():
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
def input1(type=int):
return type(input())
def input2(type=int):
[a, b] = list(map(type, input().split()))
return a, b
def input3(type=int):
[a, b, c] = list(map(type, input().split()))
return a, b, c
def input_array(type=int):
return list(map(type, input().split()))
def input_string():
s = input()
return list(s)
if is_it_local():
def debug(*args):
st = ""
for arg in args:
st += f"{arg} "
print(st)
else:
def debug(*args):
pass
##############################################################
import heapq
def main():
n = input1()
ar = input_array()
mp = {}
flg = 1
last = 0
for i in range(n-1, -1, -1):
if ar[i] not in mp:
mp[ar[i]] = 0
mp[ar[i]] += 1
last = max(last, ar[i])
if ar[i] > i + 1:
flg = 0
if flg == 0:
print(-1)
exit()
ll = []
heapq.heapify(ll)
for i in range(0, last):
if mp.get(i, 0) == 0:
heapq.heappush(ll, i)
res = []
for v in ar:
now = -1
if len(ll) > 0:
now = heapq.heappop(ll)
# heapq.remove(now)
else:
now = last + 1
res.append(now)
mp[v] -= 1
if mp[v] == 0:
heapq.heappush(ll, v)
print(" ".join(str(x) for x in res))
pass
if __name__ == '__main__':
# READ('in.txt')
main()
``` | output | 1 | 6,748 | 12 | 13,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,749 | 12 | 13,498 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
l=[]
r=[]
s1=set(a)
s2=set([int(x) for x in range(n+2)])
s3=s2.difference(s1)
r=list(s3)
r.sort()
l.append(r[0])
r.remove(r[0])
for i in range(1,n):
if a[i-1]!=a[i]:
l.append(a[i-1])
else:
l.append(r[0])
r.remove(r[0])
print(*l)
``` | output | 1 | 6,749 | 12 | 13,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,750 | 12 | 13,500 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
n=int(input())
l=list(map(int,input().split()))
d={}
l1=[0]*(10**5+1)
cnt=0
l3=[]
for i in l:
if i not in d:
d[i]=0
for i in range(len(l1)):
if i in d:
continue
else:
l1[i]=1
l2=[]
for i in range(len(l1)):
if l1[i]!=0:
l2.append(i)
else:
l3.append(i)
j,z=0,0
l4=[]
for i in range(len(l)):
if l[i]>l3[j]:
l4.append(l3[j])
j+=1
else:
l4.append(l2[z])
z+=1
print(*l4)
``` | output | 1 | 6,750 | 12 | 13,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,751 | 12 | 13,502 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
import sys
n = int(input())
mas = list(map(int, input().split()))
s = set(mas)
now = 1
p = 0
for i in range(n):
if mas[i] != p:
print(p, end = ' ')
p = mas[i]
if now == mas[i]:
now += 1
else:
while now in s:
now += 1
print(now, end = ' ')
now += 1
print()
``` | output | 1 | 6,751 | 12 | 13,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,752 | 12 | 13,504 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
import sys
def II():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def MI():
return map(int, sys.stdin.readline().split())
def SI():
return sys.stdin.readline().strip()
n = II()
a = LI()
if a[0] not in [0,1] or a!=sorted(a):
print(-1)
else:
boo = True
for i in range(n):
if a[i]>i+1:
boo = False
break
if boo == False:
print(-1)
else:
b = [-1]*n
arr = list(range(n))
if a[-1] <n:
arr = list(range(n+1))
arr.pop(a[-1])
d = {}
for i in arr:
d[i] = 0
for i in range(n-1,0,-1):
if a[i]>a[i-1]:
b[i] = a[i-1]
d[a[i-1]] = 1
temp = 0
for i in range(n):
if b[i] == -1:
while(d[arr[temp]] == 1):
temp+=1
b[i] = arr[temp]
temp+=1
print(*b)
``` | output | 1 | 6,752 | 12 | 13,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid. | instruction | 0 | 6,753 | 12 | 13,506 |
Tags: brute force, constructive algorithms, greedy
Correct Solution:
```
n = int(input())
a = [int(i) for i in input().split(' ')]
b = [0] * n
count = 0
idxs = []
if a[0] == 0:
idxs.append(0)
else:
b[0] = 0
ok = True
for i in range(1, n):
if a[i] == a[i - 1]:
idxs.append(i)
else:
b[i] = a[i - 1]
k = 1
while k < a[i] - a[i - 1]:
if len(idxs) == 0:
ok = False
print(-1)
break
b[idxs.pop()] = a[i - 1] + k
k += 1
if not ok:
break
max_v = a[-1] * 2 if a[-1] != 0 else 1
while len(idxs):
b[idxs.pop()] = max_v
s = ''
for i in b:
s += f'{i} '
print(s)
``` | output | 1 | 6,753 | 12 | 13,507 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid.
Submitted Solution:
```
# kartikay26
"""
https://codeforces.com/contest/1364/problem/C
Idea:
- whenever MEX increases it means that number was added
- when MEX increases by more than 1 it means the numbers
in between were previously added
- create "slots" for numbers we do not know, then fill later
with n+1 or the numbers that we find later which should
have come before
"""
def main():
n = int(input())
mex = [int(x) for x in input().split()]
arr = [n+1] * n
prev_mex = 0
slots = []
for i in range(n):
if mex[i] > prev_mex:
arr[i] = prev_mex
nums_to_add = range(prev_mex+1,mex[i])
for num in nums_to_add:
if len(slots) == 0:
print(-1)
return
slot = slots.pop()
arr[slot] = num
else:
slots.append(i)
prev_mex = mex[i]
# print(arr)
print(" ".join(str(x) for x in arr))
if __name__ == "__main__":
main()
``` | instruction | 0 | 6,754 | 12 | 13,508 |
Yes | output | 1 | 6,754 | 12 | 13,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid.
Submitted Solution:
```
from collections import deque
N = int(input())
List = [int(x) for x in input().split()]
for i in range(N):
if(List[i]>i+1):
print(-1)
exit()
Nahi = list(set(list(range(N+1))).difference(set(List)))
Nahi.sort()
Ans = [Nahi[0]]
Added = deque()
Added.append(List[0])
index = 1
for i in range(1,N):
if(List[i]==List[i-1]):
if(Added[-1]!=List[i]):
Added.append(List[i])
Ans.append(Nahi[index])
index+=1
else:
Ans.append(Added[0])
Added.popleft()
Added.append(List[i])
print(*Ans)
``` | instruction | 0 | 6,756 | 12 | 13,512 |
Yes | output | 1 | 6,756 | 12 | 13,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given an array a of length n, find another array, b, of length n such that:
* for each i (1 ≤ i ≤ n) MEX(\\{b_1, b_2, …, b_i\})=a_i.
The MEX of a set of integers is the smallest non-negative integer that doesn't belong to this set.
If such array doesn't exist, determine this.
Input
The first line contains an integer n (1 ≤ n ≤ 10^5) — the length of the array a.
The second line contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ i) — the elements of the array a. It's guaranteed that a_i ≤ a_{i+1} for 1≤ i < n.
Output
If there's no such array, print a single line containing -1.
Otherwise, print a single line containing n integers b_1, b_2, …, b_n (0 ≤ b_i ≤ 10^6)
If there are multiple answers, print any.
Examples
Input
3
1 2 3
Output
0 1 2
Input
4
0 0 0 2
Output
1 3 4 0
Input
3
1 1 3
Output
0 2 1
Note
In the second test case, other answers like [1,1,1,0], for example, are valid.
Submitted Solution:
```
def get_not_elements(a:list):
elements = set(a)
max_element = a[-1] +2
not_elements = []
for i in range(0,max_element):
if not i in elements:
not_elements.append(i)
not_elements.reverse()
return not_elements
#Ahora pensar esta funcion...
def is_valid(a : list):
if 0 in a and 1 in a:
return False
for i in range(len(a)):
if a[i]-1 > i:
return False
return True
def generate_array(a : list):
stack_ = get_not_elements(a)
b = [-1 for i in range(len(a))]
val = a[0]
for i in range(1,len(a)):
if a[i] != val:
b[i] = val
val = a[i]
if len(stack_)>0:
val = stack_.pop()
else:
val = a[0]
for i in range(len(a)):
if b[i] == -1:
b[i] = val
if len(stack_)>0:
val = stack_.pop()
return b
if __name__ == "__main__":
size =int(input())
array = [int(i) for i in input().split()]
if not is_valid(array):
print(-1)
else:
b = generate_array(array)
b = " ".join([str(i) for i in b])
print(b)
``` | instruction | 0 | 6,761 | 12 | 13,522 |
No | output | 1 | 6,761 | 12 | 13,523 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,778 | 12 | 13,556 |
Tags: greedy, implementation, math
Correct Solution:
```
for _ in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
mex1=0
for i in range(102):
for j in range(n):
if arr[j]==mex1:
mex1+=1
arr[j]=-1
break
mex2=0
for i in range(102):
for j in range(n):
if arr[j]==mex2:
mex2+=1
arr[j]=-1
break
print(str(mex1+mex2))
``` | output | 1 | 6,778 | 12 | 13,557 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,779 | 12 | 13,558 |
Tags: greedy, implementation, math
Correct Solution:
```
for i in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
a.sort()
if a.count(0) ==0:
print(0)
elif a.count(0) ==1:
for i in range(len(a)+2):
if i not in a:
print(i)
break
else:
for i in range(1,len(a)+2):
if a.count(i) <2:
if a.count(i) ==1:
b =i
while b+1 in a:
b+=1
print(b+i+1)
break
elif a.count(i) ==0:
print(int(2*i))
break
elif 1>0:
print(i+i+1)
break
``` | output | 1 | 6,779 | 12 | 13,559 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,780 | 12 | 13,560 |
Tags: greedy, implementation, math
Correct Solution:
```
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
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")
# ------------------- fast io --------------------
from math import gcd, ceil
def pre(s):
n = len(s)
pi = [0] * n
for i in range(1, n):
j = pi[i - 1]
while j and s[i] != s[j]:
j = pi[j - 1]
if s[i] == s[j]:
j += 1
pi[i] = j
return pi
def prod(a):
ans = 1
for each in a:
ans = (ans * each)
return ans
def lcm(a, b): return a * b // gcd(a, b)
def binary(x, length=16):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
n = int(input())
#n, k = map(int, input().split())
#a, b = map(int, input().split())
#c, d = map(int, input().split())
a = list(map(int, input().split()))
#b = list(map(int, input().split()))
#s = input()
di = {}
for i in a:
di[i] = 1 if i not in di else di[i] + 1
mex = 0
two = 0
twopos = True
for i in range(n):
if i in di:
mex += 1
if twopos and di[i] >= 2:
two += 2
else:
two += 1
twopos = False
else:break
if mex == n:
print(mex)
continue
print(max(mex, two))
``` | output | 1 | 6,780 | 12 | 13,561 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,781 | 12 | 13,562 |
Tags: greedy, implementation, math
Correct Solution:
```
# map(int, input().split())
rw = int(input())
for wewq in range(rw):
n = int(input())
a = list(map(int, input().split()))
b = 0
c = 0
for i in range(max(a) + 1):
f = a.count(i)
if f == 0:
break
elif f == 1:
b += 1
elif f >= 2 and b == c:
b += 1
c += 1
elif f >= 2 and b != c:
b += 1
print(b + c)
``` | output | 1 | 6,781 | 12 | 13,563 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,782 | 12 | 13,564 |
Tags: greedy, implementation, math
Correct Solution:
```
def mex(arr):
if len(arr) == 0: return 0
arr.sort()
if arr[0] > 0: return 0
for i in range(len(arr) - 1):
if arr[i+1] - arr[i] > 1: return arr[i] + 1
return arr[-1] + 1
if __name__ == '__main__':
num_test_cases = int(input())
for i in range(num_test_cases):
size = int(input())
occ = {}
my_set = []
tmp = input().strip().split(" ")
for n in tmp:
m = int(n)
my_set.append(m)
occ[m] = occ.get(m, 0) + 1
keys_sorted = sorted(occ)
my_set = []
for key in keys_sorted:
if occ[key] >= 2:
my_set += [key, key]
else:
my_set += [key]
if my_set[0] != 0:
print(0)
continue
if len(my_set) > 1 and my_set[1] == 0:
# my_set contains two zeros at least
i = 1
end = len(keys_sorted)
while True and i < end:
if keys_sorted[i] != i or occ[keys_sorted[i]] < 2:
break
i += 1
if i == end:
result = (keys_sorted[i-1]+1) * 2
else:
if occ[keys_sorted[i]] >= 2:
result = i * 2
elif keys_sorted[i] == i:
i += 1
result = i
while True and i < end:
if keys_sorted[i] != i:
break
i += 1
result += keys_sorted[i-1]
else:
result = i * 2
print(result)
else: print(mex(my_set))
``` | output | 1 | 6,782 | 12 | 13,565 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,783 | 12 | 13,566 |
Tags: greedy, implementation, math
Correct Solution:
```
import os
from io import BytesIO, IOBase
import sys
def main():
from collections import Counter
for t in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = Counter(a)
c = []
d = []
for i in range(max(a) + 1):
if b[i] >= 2:
c.append(i)
d.append(i)
else:
if b[i] == 1:
c.append(i)
ans = 0
flag = 0
for i in range(len(c)):
if i != c[i]:
ans += i
flag = 1
break
if flag == 0:
ans = c[-1] + 1
flag = 0
for i in range(len(d)):
if i != d[i]:
ans += i
flag = 1
break
if flag == 0:
if d != []:
ans += d[-1] + 1
print(ans)
# 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 | 6,783 | 12 | 13,567 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,784 | 12 | 13,568 |
Tags: greedy, implementation, math
Correct Solution:
```
import sys
import math
from math import *
from collections import Counter,defaultdict,deque
lip = lambda : list(map(int, input().split()))
ip = lambda : int(input())
sip = lambda : input().split()
def main():
n = ip()
arr = lip()
set1 = set()
set2 = set()
d1 = defaultdict(lambda:False)
d2 = defaultdict(lambda:False)
for i in arr:
if i in set1:
set2.add(i)
d2[i] = True
else:
d1[i] = True
set1.add(i)
A = 0
for i in range(len(set1)+2):
if not d1[i]:
A = i
break
B = 0
for i in range(len(set2)+2):
if not d2[i]:
B = i
break
print(A+B)
for i in range(ip()):
main()
``` | output | 1 | 6,784 | 12 | 13,569 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice. | instruction | 0 | 6,785 | 12 | 13,570 |
Tags: greedy, implementation, math
Correct Solution:
```
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().rstrip().split())
inl = lambda: list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
t = ini()
for _ in range(t):
n = ini()
a = inl()
first = second = -1
for i in range(101):
if a.count(i) > 1:
continue
if a.count(i) == 1 and first == -1:
first = i
continue
if a.count(i) == 0:
first = i if first == -1 else first
second = i
break
print(first+second)
``` | output | 1 | 6,785 | 12 | 13,571 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
def mex(arr):
if len(arr)==0:
return 0
for i in range(max(arr)+2):
if i not in arr:
res=i
return res
for i in range(int(input())):
n=int(input())
arr=list(map(int,input().split()))
arr.sort()
a=[]
b=[]
i=0
while i<len(arr)-1:
if arr[i+1]==arr[i]:
a.append(arr[i])
b.append(arr[i+1])
i+=2
else:
a.append(arr[i])
i+=1
a.append(arr[len(arr)-1])
print(mex(a)+mex(b))
``` | instruction | 0 | 6,786 | 12 | 13,572 |
Yes | output | 1 | 6,786 | 12 | 13,573 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
from sys import stdin
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
a = sorted(map(int, stdin.readline().split()))
mex_a, mex_b = 0, 0
for i in a:
if i == mex_a:
mex_a += 1
elif i == mex_b:
mex_b += 1
print(mex_a + mex_b)
``` | instruction | 0 | 6,787 | 12 | 13,574 |
Yes | output | 1 | 6,787 | 12 | 13,575 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
l=list(map(int,input().split()))
s=list(set(l))
f=0
res=0
for i in range(0,101):
cnt=l.count(i)
if cnt==0 and f==0:
res=2*i
break
elif cnt<=1:
if f==0:
res+=i
f=1
elif f==1 and cnt==0:
res+=i
break
print(res)
``` | instruction | 0 | 6,788 | 12 | 13,576 |
Yes | output | 1 | 6,788 | 12 | 13,577 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
from collections import Counter
for _ in range(int(input())):
n=int(input())
arr = list(map(int, input().split()))
arr=sorted(arr)
c=Counter(arr)
ls=[]
a=[]
for i in c:
if c[i]==1:
ls.append(i)
else:
ls.append(i)
a.append(i)
ans=0
f=0
f1=0
for i in range(101):
if f==0 and i not in ls:
ans+=i
f=1
if f1==0 and i not in a:
ans+=i
f1=1
if f==1 and f1==1:
break
print(ans)
``` | instruction | 0 | 6,789 | 12 | 13,578 |
Yes | output | 1 | 6,789 | 12 | 13,579 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
cases=int(input())
for _ in range(cases):
n=int(input())
c=list(map(int,input().split()))
l=sorted(c)
x=[]
y=[]
visx=[]
visy=[]
for i in range(len(l)):
if l[i] not in visx:
x.append(l[i])
visx.append(l[i])
else:
y.append(l[i])
visy.append(l[i])
index=0
flag=0
tot=0
for i in range(len(x)):
if x[i]==index:
index+=1
else:
flag=1
break
tot+=index
index=0
flag=0
for i in range(len(y)):
if y[i]==index:
index+=1
else:
flag=1
break
tot+=index
print(tot)
``` | instruction | 0 | 6,790 | 12 | 13,580 |
No | output | 1 | 6,790 | 12 | 13,581 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
t=int(input())
for _ in range(t):
n=int(input())
l1=list(map(int,input().split()))
l2=list(set(l1))
l3=[]
l2.sort()
x,y=min(l2),max(l2)
ans=0
if x==0:
f,c=0,0
ans=0
for i in range(x,y+1):
if i not in l2:
c=i
f=1
break
if f==0:
ans+=y+1
else:
ans+=c
if len(l1)!=len(l2):
for i in l2:
if l1.count(i)>1:
l3.append(i)
x,y=min(l3),max(l3)
f,c=0,0
for i in range(x,y+1):
if i not in l3:
c=i
f=1
break
if f==0:
ans+=y+1
else:
ans+=c
print(ans)
``` | instruction | 0 | 6,791 | 12 | 13,582 |
No | output | 1 | 6,791 | 12 | 13,583 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
l = [0 for i in range(101)]
for i in a:
l[i]+=1
s = 0
mn = l[0]
for i in range(101):
if mn == 0 or l[i]==0:
break
if l[i]>=mn:
s+=mn
elif l[i]<mn:
mn = l[i]
s+=mn
print(s)
``` | instruction | 0 | 6,792 | 12 | 13,584 |
No | output | 1 | 6,792 | 12 | 13,585 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Given a set of integers (it can contain equal elements).
You have to split it into two subsets A and B (both of them can contain equal elements or be empty). You have to maximize the value of mex(A)+mex(B).
Here mex of a set denotes the smallest non-negative integer that doesn't exist in the set. For example:
* mex(\{1,4,0,2,2,1\})=3
* mex(\{3,3,2,1,3,0,0\})=4
* mex(∅)=0 (mex for empty set)
The set is splitted into two subsets A and B if for any integer number x the number of occurrences of x into this set is equal to the sum of the number of occurrences of x into A and the number of occurrences of x into B.
Input
The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 100) — the number of test cases. The description of the test cases follows.
The first line of each test case contains an integer n (1≤ n≤ 100) — the size of the set.
The second line of each testcase contains n integers a_1,a_2,... a_n (0≤ a_i≤ 100) — the numbers in the set.
Output
For each test case, print the maximum value of mex(A)+mex(B).
Example
Input
4
6
0 2 1 5 0 1
3
0 1 2
4
0 2 0 1
6
1 2 3 4 5 6
Output
5
3
4
0
Note
In the first test case, A=\left\{0,1,2\right\},B=\left\{0,1,5\right\} is a possible choice.
In the second test case, A=\left\{0,1,2\right\},B=∅ is a possible choice.
In the third test case, A=\left\{0,1,2\right\},B=\left\{0\right\} is a possible choice.
In the fourth test case, A=\left\{1,3,5\right\},B=\left\{2,4,6\right\} is a possible choice.
Submitted Solution:
```
for t in range(int(input())):
n=int(input())
a=list(sorted(map(int,input().split())))
ans=0
j=0
m=True
d={}
for i in a:
if i not in d:
d[i]=1
else:
d[i]+=1
d=dict(sorted(d.items(),key=lambda x:x[0]))
for i in range(n+1):
if i not in d:
break
elif d[i]==1 and m:
m=False
j=i
print(i+j)
``` | instruction | 0 | 6,793 | 12 | 13,586 |
No | output | 1 | 6,793 | 12 | 13,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant has got a problem — somebody has been touching his sorted by non-decreasing array a of length n and possibly swapped some elements of the array.
The Little Elephant doesn't want to call the police until he understands if he could have accidentally changed the array himself. He thinks that he could have accidentally changed array a, only if array a can be sorted in no more than one operation of swapping elements (not necessarily adjacent). That is, the Little Elephant could have accidentally swapped some two elements.
Help the Little Elephant, determine if he could have accidentally changed the array a, sorted by non-decreasing, himself.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the size of array a. The next line contains n positive integers, separated by single spaces and not exceeding 109, — array a.
Note that the elements of the array are not necessarily distinct numbers.
Output
In a single line print "YES" (without the quotes) if the Little Elephant could have accidentally changed the array himself, and "NO" (without the quotes) otherwise.
Examples
Input
2
1 2
Output
YES
Input
3
3 2 1
Output
YES
Input
4
4 3 2 1
Output
NO
Note
In the first sample the array has already been sorted, so to sort it, we need 0 swap operations, that is not more than 1. Thus, the answer is "YES".
In the second sample we can sort the array if we swap elements 1 and 3, so we need 1 swap operation to sort the array. Thus, the answer is "YES".
In the third sample we can't sort the array in more than one swap operation, so the answer is "NO". | instruction | 0 | 6,910 | 12 | 13,820 |
Tags: implementation, sortings
Correct Solution:
```
n=int(input())
l=[int(i) for i in input().split()]
l1=sorted(l)
c=0
for i in range(n):
if(l1[i]!=l[i]):
c+=1
if(c>2):
print("NO")
else:
print("YES")
``` | output | 1 | 6,910 | 12 | 13,821 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant has got a problem — somebody has been touching his sorted by non-decreasing array a of length n and possibly swapped some elements of the array.
The Little Elephant doesn't want to call the police until he understands if he could have accidentally changed the array himself. He thinks that he could have accidentally changed array a, only if array a can be sorted in no more than one operation of swapping elements (not necessarily adjacent). That is, the Little Elephant could have accidentally swapped some two elements.
Help the Little Elephant, determine if he could have accidentally changed the array a, sorted by non-decreasing, himself.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the size of array a. The next line contains n positive integers, separated by single spaces and not exceeding 109, — array a.
Note that the elements of the array are not necessarily distinct numbers.
Output
In a single line print "YES" (without the quotes) if the Little Elephant could have accidentally changed the array himself, and "NO" (without the quotes) otherwise.
Examples
Input
2
1 2
Output
YES
Input
3
3 2 1
Output
YES
Input
4
4 3 2 1
Output
NO
Note
In the first sample the array has already been sorted, so to sort it, we need 0 swap operations, that is not more than 1. Thus, the answer is "YES".
In the second sample we can sort the array if we swap elements 1 and 3, so we need 1 swap operation to sort the array. Thus, the answer is "YES".
In the third sample we can't sort the array in more than one swap operation, so the answer is "NO". | instruction | 0 | 6,911 | 12 | 13,822 |
Tags: implementation, sortings
Correct Solution:
```
#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
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")
def value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]
#-------------------------code---------------------------#
#vsInput()
n=Int()
a=array()
sorted_a=sorted(a)
disturbed=[]
for i in range(n):
if(a[i]!=sorted_a[i]):
disturbed.append(i)
if(len(disturbed)<=2): print("YES")
else: print("NO")
``` | output | 1 | 6,911 | 12 | 13,823 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant has got a problem — somebody has been touching his sorted by non-decreasing array a of length n and possibly swapped some elements of the array.
The Little Elephant doesn't want to call the police until he understands if he could have accidentally changed the array himself. He thinks that he could have accidentally changed array a, only if array a can be sorted in no more than one operation of swapping elements (not necessarily adjacent). That is, the Little Elephant could have accidentally swapped some two elements.
Help the Little Elephant, determine if he could have accidentally changed the array a, sorted by non-decreasing, himself.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the size of array a. The next line contains n positive integers, separated by single spaces and not exceeding 109, — array a.
Note that the elements of the array are not necessarily distinct numbers.
Output
In a single line print "YES" (without the quotes) if the Little Elephant could have accidentally changed the array himself, and "NO" (without the quotes) otherwise.
Examples
Input
2
1 2
Output
YES
Input
3
3 2 1
Output
YES
Input
4
4 3 2 1
Output
NO
Note
In the first sample the array has already been sorted, so to sort it, we need 0 swap operations, that is not more than 1. Thus, the answer is "YES".
In the second sample we can sort the array if we swap elements 1 and 3, so we need 1 swap operation to sort the array. Thus, the answer is "YES".
In the third sample we can't sort the array in more than one swap operation, so the answer is "NO". | instruction | 0 | 6,912 | 12 | 13,824 |
Tags: implementation, sortings
Correct Solution:
```
#https://codeforces.com/contest/221/problem/C
n=int(input())
a=list(map(int,input().split(' ')))
b=[]
for i in range(n):
b.append(a[i])
b.sort()
q=0
R=[]
bhul=True
for i in range(n):
if a[i]!=b[i]:
if q>=2:
print('NO')
bhul=False
break
else:
q+=1
R.append(i)
if bhul:
if q==0:
print('YES')
elif q==2:
print('YES')
else:
print('NO')
``` | output | 1 | 6,912 | 12 | 13,825 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The Little Elephant has got a problem — somebody has been touching his sorted by non-decreasing array a of length n and possibly swapped some elements of the array.
The Little Elephant doesn't want to call the police until he understands if he could have accidentally changed the array himself. He thinks that he could have accidentally changed array a, only if array a can be sorted in no more than one operation of swapping elements (not necessarily adjacent). That is, the Little Elephant could have accidentally swapped some two elements.
Help the Little Elephant, determine if he could have accidentally changed the array a, sorted by non-decreasing, himself.
Input
The first line contains a single integer n (2 ≤ n ≤ 105) — the size of array a. The next line contains n positive integers, separated by single spaces and not exceeding 109, — array a.
Note that the elements of the array are not necessarily distinct numbers.
Output
In a single line print "YES" (without the quotes) if the Little Elephant could have accidentally changed the array himself, and "NO" (without the quotes) otherwise.
Examples
Input
2
1 2
Output
YES
Input
3
3 2 1
Output
YES
Input
4
4 3 2 1
Output
NO
Note
In the first sample the array has already been sorted, so to sort it, we need 0 swap operations, that is not more than 1. Thus, the answer is "YES".
In the second sample we can sort the array if we swap elements 1 and 3, so we need 1 swap operation to sort the array. Thus, the answer is "YES".
In the third sample we can't sort the array in more than one swap operation, so the answer is "NO". | instruction | 0 | 6,913 | 12 | 13,826 |
Tags: implementation, sortings
Correct Solution:
```
n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
ans = 0
for i in range(n):
if not a[i] == b[i]:
ans += 1
if ans <= 2:
print("YES")
else:
print("NO")
``` | output | 1 | 6,913 | 12 | 13,827 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.