message stringlengths 2 433k | message_type stringclasses 2
values | message_id int64 0 1 | conversation_id int64 113 108k | cluster float64 12 12 | __index_level_0__ int64 226 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,010 | 12 | 124,020 |
Tags: data structures, greedy, sortings
Correct Solution:
```
import sys
n,k1,k2=map(int,input().split())
a=[int(i) for i in sys.stdin.readline().split()]
b=[int(i) for i in sys.stdin.readline().split()]
for i in range(n):
a[i]=abs(a[i]-b[i])
for i in range(k1+k2):
c=a.index(max(a))
a[c]=abs(a[c]-1)
su=0
for i in a:
su+=(i*i)
print(su)
``` | output | 1 | 62,010 | 12 | 124,021 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,011 | 12 | 124,022 |
Tags: data structures, greedy, sortings
Correct Solution:
```
n,k1,k2 = map(int,input().split())
a = list(map(int,input().split()))[:n]
b = list(map(int,input().split()))[:n]
c = [abs(a[i]-b[i]) for i in range(n)]
ans = 0
for i in range(n):
ans += c[i]*c[i]
#print(ans)
#print(*c)
for i in range(k1+k2):
c.sort(reverse=True)
ans-=2*c[0]-1
c[0]-=1
c[0]=abs(c[0])
print(ans)
``` | output | 1 | 62,011 | 12 | 124,023 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,012 | 12 | 124,024 |
Tags: data structures, greedy, sortings
Correct Solution:
```
n, k1, k2 = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
k = k1+k2
c = list()
for i in range(n):
c.append(abs(a[i]-b[i]))
c.sort()
for i in range(n-1, 0, -1):
if c[i] == c[i-1]:
continue
if (n-i)*(c[i]-c[i-1]) <= k:
k = k-(n-i)*(c[i]-c[i-1])
for j in range(i, n):
c[j] = c[i-1]
else:
while k > 0:
for j in range(n-1, i-1, -1):
c[j] = c[j]-1
k = k-1
if k == 0:
break
while k > 0 and c[0] > 0:
for i in range(n):
c[i] = c[i]-1
k = k-1
if k == 0:
break
if k > 0:
if k&1:
sum = 1
else:
sum = 0
else:
sum = 0
for i in range(n):
sum = sum+c[i]*c[i]
print(sum)
``` | output | 1 | 62,012 | 12 | 124,025 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,013 | 12 | 124,026 |
Tags: data structures, greedy, sortings
Correct Solution:
```
import heapq
n,k1,k2=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[]
for i in range(n):
c.append(-1*abs(a[i]-b[i]))
heapq.heapify(c)
e=1
for i in range(k1+k2):
if c[0]<0:
heapq.heapreplace(c,(c[0]+1))
e=1
elif c[0]==0:
print(((k1+k2)-i)%2)
e=0
break
if e==1:
s=0
for i in range(n):
s=s+c[i]**2
print(s)
``` | output | 1 | 62,013 | 12 | 124,027 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,014 | 12 | 124,028 |
Tags: data structures, greedy, sortings
Correct Solution:
```
n, k1, k2 = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
d = [abs(a[i] - b[i]) for i in range(n)]
for i in range(k1):
ind = d.index(max(d))
d[ind] = abs(d[ind] - 1)
for i in range(k2):
ind = d.index(max(d))
d[ind] = abs(d[ind] - 1)
s = 0
for i in range(n):
s += d[i] ** 2
print(s)
``` | output | 1 | 62,014 | 12 | 124,029 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,015 | 12 | 124,030 |
Tags: data structures, greedy, sortings
Correct Solution:
```
n,k1,k2=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[]
for i in range(n):
c.append(-abs(a[i]-b[i]))
from heapq import heapify,heappush as pu,heappop as po
heapify(c)
for i in range(k1+k2):
x=po(c)
if x>=0:
pu(c,x-1)
else:
pu(c,x+1)
ans=0
for i in c:
ans+=i*i
print(ans)
``` | output | 1 | 62,015 | 12 | 124,031 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,016 | 12 | 124,032 |
Tags: data structures, greedy, sortings
Correct Solution:
```
R = lambda: map(int, input().split())
n, k1, k2 = R()
diff = [abs(x1 - x2) for x1, x2 in zip(R(), R())]
for _ in range(k1+k2):
diff.sort()
diff[-1] = abs(diff[-1] - 1)
print(sum(i ** 2 for i in diff))
``` | output | 1 | 62,016 | 12 | 124,033 |
Provide tags and a correct Python 3 solution for this coding contest problem.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1. | instruction | 0 | 62,017 | 12 | 124,034 |
Tags: data structures, greedy, sortings
Correct Solution:
```
[n, k1, k2] = [int(x) for x in input().split()]
k = k1+k2
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
error = [abs(x[0] - x[1]) for x in zip(a,b)]
error = sorted(error, reverse=True)
if k >= sum(error):
print((k-sum(error))%2)
exit()
index = 0
while k != 0:
error[index] -= 1
if index+1 == n:
index = 0
elif error[index]+1 == error[index+1]:
index += 1
else:
index = 0
k -= 1
print(sum([x*x for x in error]))
``` | output | 1 | 62,017 | 12 | 124,035 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
s = input().split()
n, k1, k2 = int(s[0]), int(s[1]), int(s[2])
k = k1+k2
a = list(map(int, input().split()))
b = list(map(int, input().split()))
cl = []
for i in range(n):
cl.append(abs(a[i]-b[i]))
for i in range(k):
cl[cl.index(max(cl))] = abs(max(cl)-1)
res = 0
for x in range(n):
res+=cl[x]**2
print(res)
``` | instruction | 0 | 62,018 | 12 | 124,036 |
Yes | output | 1 | 62,018 | 12 | 124,037 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
firstLine = input().strip().split(" ")
n = int(firstLine[0])
k1 = int(firstLine[1])
k2 = int(firstLine[2])
A = list(map(int,input().strip().split(" ")))
B = list(map(int,input().strip().split(" ")))
def findErrorInRankingTable():
error = 0
for item in rankingTable:
error += item[3]
return error
"""Apply the addition or subtraction to the largest difference so that it minimizes error."""
"""Rank: 0 1 2 3
A
B
D
"""
rankingTable = []
for i in range(n):
difference = A[i]-B[i]
rankingTable.append([i,A[i],B[i],difference**2])
#Sort the rankings by difference.
rankingTable.sort(key = lambda item: item[3])
#print(rankingTable)
#apply the k1 operations.
for i in range(k1):
#Move the a value closer to the b value.
if rankingTable[n-1][1] < rankingTable[n-1][2]:
rankingTable[n-1][1] += 1
else:
rankingTable[n-1][1] -= 1
#Recalculate difference.
rankingTable[n-1][3] = (rankingTable[n-1][1] - rankingTable[n-1][2])**2
#print(rankingTable)
#Percolate new largest difference up if needed.
rankingTable.sort(key = lambda item: item[3])
#apply the k2 operations.
for i in range(k2):
#Move the a value closer to the b value.
if rankingTable[n-1][2] < rankingTable[n-1][1]:
rankingTable[n-1][2] += 1
else:
rankingTable[n-1][2] -= 1
#Recalculate difference.
rankingTable[n-1][3] = (rankingTable[n-1][1] - rankingTable[n-1][2])**2
#print(rankingTable)
#Percolate new largest difference up if needed.
rankingTable.sort(key = lambda item: item[3])
#print(rankingTable)
print(findErrorInRankingTable())
``` | instruction | 0 | 62,019 | 12 | 124,038 |
Yes | output | 1 | 62,019 | 12 | 124,039 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
import sys
import heapq
# from collections import deque
# from collections import Counter
# from math import sqrt
# from math import log
# from math import ceil
# from bisect import bisect_left, bisect_right
# alpha=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# mod=10**9+7
# mod=998244353
# def BinarySearch(a,x):
# i=bisect_left(a,x)
# if(i!=len(a) and a[i]==x):
# return i
# else:
# return -1
# def sieve(n):
# prime=[True for i in range(n+1)]
# p=2
# while(p*p<=n):
# if (prime[p]==True):
# for i in range(p*p,n+1,p):
# prime[i]=False
# p+=1
# prime[0]=False
# prime[1]=False
# s=set()
# for i in range(len(prime)):
# if(prime[i]):
# s.add(i)
# return s
# def gcd(a, b):
# if(a==0):
# return b
# return gcd(b%a,a)
fast_reader=sys.stdin.readline
fast_writer=sys.stdout.write
def input():
return fast_reader().strip()
def print(*argv):
fast_writer(' '.join((str(i)) for i in argv))
fast_writer('\n')
#____________________________________________________________________________________________________________________________________
for _ in range(1):
n,k1,k2=map(int, input().split())
a=list(map(int, input().split()))
b=list(map(int, input().split()))
c=[-abs(a[i]-b[i]) for i in range(n)]
heapq.heapify(c)
k=k1+k2
while(k!=0):
pp=heapq.heappop(c)
if(pp<0):
heapq.heappush(c,pp+1)
else:
heapq.heappush(c,pp-1)
k-=1
ans=0
#print(c)
for i in c:
ans+=i**2
print(ans)
``` | instruction | 0 | 62,020 | 12 | 124,040 |
Yes | output | 1 | 62,020 | 12 | 124,041 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
n, k1, k2 = map(int, input().split())
a1 = list(map(int, input().split()))
a2 = list(map(int, input().split()))
e = []
for i in range(n):
e.append(abs(a1[i]-a2[i]))
#print(e)
for k in range(k1+k2):
e[e.index(max(e))] = abs(max(e) - 1)
print(sum(i * i for i in e))
``` | instruction | 0 | 62,021 | 12 | 124,042 |
Yes | output | 1 | 62,021 | 12 | 124,043 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
n,k1,k2 = map(int,input().split())
a = list(map(int,input().split()))[:n]
b = list(map(int,input().split()))[:n]
c = [abs(a[i]-b[i]) for i in range(n)]
ans = 0
for i in range(n):
ans += c[i]*c[i]
#print(ans)
#print(*c)
for i in range(k1+k2):
c.sort(reverse=True)
ans-=2*c[0]-1
c[0]-=1
if ans==0:
break
print(ans)
``` | instruction | 0 | 62,022 | 12 | 124,044 |
No | output | 1 | 62,022 | 12 | 124,045 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
n,k1,k2=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=[]
for i in range(n):
c.append(-abs(a[i]-b[i]))
from heapq import heapify,heappush as pu,heappop as po
heapify(c)
for i in range(k1+k2):
x=po(c)
if x==0:
break
pu(c,x+1)
ans=0
for i in c:
ans+=i*i
print(ans)
``` | instruction | 0 | 62,023 | 12 | 124,046 |
No | output | 1 | 62,023 | 12 | 124,047 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
import heapq
[n, k1, k2] = [int(x) for x in input().split(" ")]
A = input().split(" ")
B = input().split(" ")
error = 0
diff = [0] * n
for i in range(n):
a = int(A[i])
b = int(B[i])
diff[i] = -1 * abs(a - b)
heapq.heapify(diff)
k = k1 + k2
error = 0
for i in range(k):
tmp = heapq.heappop(diff)
if tmp == 0 and i != k - 1:
error = 0 if k % 2 == 0 else 1
break
heapq.heappush(diff, tmp + 1)
for i in diff:
error = error + i * i
print(error)
``` | instruction | 0 | 62,024 | 12 | 124,048 |
No | output | 1 | 62,024 | 12 | 124,049 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given two arrays A and B, each of size n. The error, E, between these two arrays is defined <image>. You have to perform exactly k1 operations on array A and exactly k2 operations on array B. In one operation, you have to choose one element of the array and increase or decrease it by 1.
Output the minimum possible value of error after k1 operations on array A and k2 operations on array B have been performed.
Input
The first line contains three space-separated integers n (1 ≤ n ≤ 103), k1 and k2 (0 ≤ k1 + k2 ≤ 103, k1 and k2 are non-negative) — size of arrays and number of operations to perform on A and B respectively.
Second line contains n space separated integers a1, a2, ..., an ( - 106 ≤ ai ≤ 106) — array A.
Third line contains n space separated integers b1, b2, ..., bn ( - 106 ≤ bi ≤ 106)— array B.
Output
Output a single integer — the minimum possible value of <image> after doing exactly k1 operations on array A and exactly k2 operations on array B.
Examples
Input
2 0 0
1 2
2 3
Output
2
Input
2 1 0
1 2
2 2
Output
0
Input
2 5 7
3 4
14 4
Output
1
Note
In the first sample case, we cannot perform any operations on A or B. Therefore the minimum possible error E = (1 - 2)2 + (2 - 3)2 = 2.
In the second sample case, we are required to perform exactly one operation on A. In order to minimize error, we increment the first element of A by 1. Now, A = [2, 2]. The error is now E = (2 - 2)2 + (2 - 2)2 = 0. This is the minimum possible error obtainable.
In the third sample case, we can increase the first element of A to 8, using the all of the 5 moves available to us. Also, the first element of B can be reduced to 8 using the 6 of the 7 available moves. Now A = [8, 4] and B = [8, 4]. The error is now E = (8 - 8)2 + (4 - 4)2 = 0, but we are still left with 1 move for array B. Increasing the second element of B to 5 using the left move, we get B = [8, 5] and E = (8 - 8)2 + (4 - 5)2 = 1.
Submitted Solution:
```
def main():
n, k1, k2 = map(int, input().split())
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
c = [(abs(a[i] - b[i])) for i in range(n)]
s = sum(c)
if s >= (k1 + k2):
after = sum(c) - (k1 + k2)
q, r = divmod(after, n)
ans = sum([q**2 for i in range(n-r)]) + sum([(q+1)**2 for i in range(r)])
else:
after = (k1 + k2) - s
if after % 2 == 0:
ans = 0
else:
ans = 1
print(ans)
if __name__ == '__main__':
main()
``` | instruction | 0 | 62,025 | 12 | 124,050 |
No | output | 1 | 62,025 | 12 | 124,051 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,026 | 12 | 124,052 |
Tags: combinatorics, math
Correct Solution:
```
n = int(input())
u = list(map(int, input().split()))
for i in range(n):
u[i] -= 1
ans = 0
for i in range(n):
if u[i] == -1:
continue
ans = 1 - ans
x = i
while x >= 0:
y = u[x]
u[x] = -1
x = y
if ans:
print('Um_nik')
else:
print('Petr')
``` | output | 1 | 62,026 | 12 | 124,053 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,027 | 12 | 124,054 |
Tags: combinatorics, math
Correct Solution:
```
from collections import *
from itertools import permutations
def li():return [int(i) for i in input().rstrip('\n').split(' ')]
def st():return input().rstrip('\n')
def val():return int(input())
def do(i):
global tot,l
temp = l[i]
l[i] = l[l[i]]
l[temp] = temp
tot += 1
n = val()
l = [0] + li()
# perm = permutations([0,1,2,3,4])
# for i in perm:print(i)
# for j in perm:
# n = 4
# l = list(j)
tot = 0
for i in range(1,n+1):
while l[i] != i:
do(i)
print('Petr' if tot%2 == n%2 else 'Um_nik')
``` | output | 1 | 62,027 | 12 | 124,055 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,028 | 12 | 124,056 |
Tags: combinatorics, math
Correct Solution:
```
import math
n = int(input())
a = list(map(int, input().split()))
if n < 10: print('Petr')
else: print(['Petr', 'Um_nik'][sum(a[i] == i + 1 for i in range(n)) < math.log(n) / 3])
``` | output | 1 | 62,028 | 12 | 124,057 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,029 | 12 | 124,058 |
Tags: combinatorics, math
Correct Solution:
```
n = int(input())
a = list(map(int,input().split()))
b = [x for x in range(1,n+1)]
c = [(x,y) for x,y in zip(a,b)]
d = set(c)
cnt = 0
while d:
x = d.pop()
sti = x[1]
while x[0] != sti:
x = c[x[0]-1]
cnt += 1
if x in d:
d.remove(x)
else:
break
if cnt%2==(n*3)%2:
print('Petr')
else:
print('Um_nik')
``` | output | 1 | 62,029 | 12 | 124,059 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,030 | 12 | 124,060 |
Tags: combinatorics, math
Correct Solution:
```
def getIntList():
return list(map(int, input().split()));
n= int(input());
s=getIntList();
s=[0]+s;
seen=[False]*(n+1);
sign=1;
for i in range(1, n+1):
length=1;
if seen[i]:
continue;
seen[i]=True;
j=s[i];
while j!=i:
seen[j]=True;
j=s[j];
length+=1;
if length%2==0:
sign*=-1;
if n%2==0:
signPetr=1;
else:
signPetr=-1;
if signPetr==sign:
print("Petr");
else:
print("Um_nik");
``` | output | 1 | 62,030 | 12 | 124,061 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,031 | 12 | 124,062 |
Tags: combinatorics, math
Correct Solution:
```
print(('Um_nik', 'Petr')[int(input()) // 1000 <= sum(i == x for i, x in enumerate(map(int, input().split()), 1))])
``` | output | 1 | 62,031 | 12 | 124,063 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,032 | 12 | 124,064 |
Tags: combinatorics, math
Correct Solution:
```
import sys
f = lambda s: int(s)-1
n = int(input())
b = [0]*(n+1)
def update(bit,idx,val):
idx += 1
while idx < n+1:
bit[idx] += val
idx += idx&(-idx)
def getSum(bit,idx):
idx += 1
ans = 0
while idx > 0:
ans += bit[idx]
idx -= idx&(-idx)
return ans
a = list(map(f,input().split()))
p = 0
for i in range(n):
s = getSum(b,a[i]-1)
p += (i+1)-s
update(b,a[i],1)
if p%2 == 0:
print("Petr")
else:
print("Um_nik")
``` | output | 1 | 62,032 | 12 | 124,065 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden. | instruction | 0 | 62,033 | 12 | 124,066 |
Tags: combinatorics, math
Correct Solution:
```
def read():
return int(input())
def readmap():
return map(int, input().split())
def readlist():
return list(map(int, input().split()))
N = read()
P = readlist()
def is_even(P):
checked = [False] * (N+1)
# numset = {}
# for n in range(1, N+1):
# numset[n] = n
num_of_even_cycles = 0
for n in range(1, N+1):
if checked[n]:
continue
checked[n] = True
len_cyc = 1
nxt = P[n-1]
while not checked[nxt]:
checked[nxt] = True
nxt = P[nxt-1]
len_cyc += 1
if len_cyc % 2 == 0:
num_of_even_cycles += 1
# while numset:
# flag = False
# for n in numset.keys():
# if flag:
# break
# flag = True
# length_of_cycle = 1
# while P[n-1] in numset:
# length_of_cycle += 1
# del numset[n]
# n = P[n-1]
#
# if length_of_cycle % 2 == 0:
# num_of_even_cycles += 1
if num_of_even_cycles % 2 == 0:
return True
else:
return False
if N % 2 == 0:
if is_even(P):
print("Petr")
else:
print("Um_nik")
else:
if not is_even(P):
print("Petr")
else:
print("Um_nik")
``` | output | 1 | 62,033 | 12 | 124,067 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
pos={}
for i in range(n):
pos[a[i]]=i
ct=0
curr=1
for i in range(n):
if pos[curr]==i:
curr+=1
continue
ct+=1
j=pos[curr]
pos[curr]=i
pos[a[i]]=j
curr+=1
a[i],a[j]=a[j],a[i]
if (3*n<ct) or (3*n-ct)&1:
print("Um_nik")
else:
print("Petr")
``` | instruction | 0 | 62,034 | 12 | 124,068 |
Yes | output | 1 | 62,034 | 12 | 124,069 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
Submitted Solution:
```
import sys
f = lambda s: int(s)-1
n = int(input())
a = list(map(f,input().split()))
seen = [False]*n
num_tran = 0
for i in range(n):
if not seen[a[i]]:
cur = a[i]
seen[cur] = True
l = 1
while not seen[a[cur]]:
seen[a[cur]] = True
cur = a[cur]
l += 1
if (l-1)%2 == 1:
num_tran = (1+num_tran)%2
if num_tran == 1:
print("Petr")
else:
print("Um_nik")
``` | instruction | 0 | 62,035 | 12 | 124,070 |
No | output | 1 | 62,035 | 12 | 124,071 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
Submitted Solution:
```
print(('Petr', 'Um_nik')[int(input()) <= sum(i == x for i, x in enumerate(map(int, input().split()), 1)) * 1000])
``` | instruction | 0 | 62,036 | 12 | 124,072 |
No | output | 1 | 62,036 | 12 | 124,073 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
Submitted Solution:
```
print(('Petr', 'Um_nik')[int(input()) >= sum(i == x for i, x in enumerate(map(int, input().split()), 1)) * 1000])
``` | instruction | 0 | 62,037 | 12 | 124,074 |
No | output | 1 | 62,037 | 12 | 124,075 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Petr likes to come up with problems about randomly generated data. This time problem is about random permutation. He decided to generate a random permutation this way: he takes identity permutation of numbers from 1 to n and then 3n times takes a random pair of different elements and swaps them. Alex envies Petr and tries to imitate him in all kind of things. Alex has also come up with a problem about random permutation. He generates a random permutation just like Petr but swaps elements 7n+1 times instead of 3n times. Because it is more random, OK?!
You somehow get a test from one of these problems and now you want to know from which one.
Input
In the first line of input there is one integer n (10^{3} ≤ n ≤ 10^{6}).
In the second line there are n distinct integers between 1 and n — the permutation of size n from the test.
It is guaranteed that all tests except for sample are generated this way: First we choose n — the size of the permutation. Then we randomly choose a method to generate a permutation — the one of Petr or the one of Alex. Then we generate a permutation using chosen method.
Output
If the test is generated via Petr's method print "Petr" (without quotes). If the test is generated via Alex's method print "Um_nik" (without quotes).
Example
Input
5
2 4 5 1 3
Output
Petr
Note
Please note that the sample is not a valid test (because of limitations for n) and is given only to illustrate input/output format. Your program still has to print correct answer to this test to get AC.
Due to randomness of input hacks in this problem are forbidden.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
print(['Petr', 'Um_nik'][sum(a[i] == i + 1 for i in range(n)) > 10])
``` | instruction | 0 | 62,038 | 12 | 124,076 |
No | output | 1 | 62,038 | 12 | 124,077 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to simulate the sequence defined in the remaining part of the problem description.
This sequence is empty at first. i -th element of this sequence is expressed as ai . The first element of this sequence is a1 if the sequence is not empty. The operation is given by integer from 0 to 9. The operation is described below.
0: This query is given with some integer x. If this query is given, the integer x is inserted into the sequence. If the sequence is empty, a1 = x. If the sequence has n elements, an+1 = x. Same integer will not appear more than once as x.
1: If this query is given, one element in the sequence is deleted. The value in the middle of the sequence is deleted. If the sequence has n elements and n is even, an/2 will be deleted. If n is odd, a⌈n/2⌉ will be deleted. This query is not given when the sequence is empty. Assume that the sequence has a1 =1, a2 =2, a3 =3, a4 =4 and a5 =5. In this case, a3 will be deleted. After deletion, the sequence will be a1 =1, a2 =2, a3 =4, a4 =5. Assume that the sequence has a1 =1, a2 =2, a3 =3 and a4 =4, In this case, a2 will be deleted. After deletion, the sequence will be a1 =1, a2 =3, a3 =4.
2: The first half of the sequence is defined by the index from 1 to ⌈n/2⌉ . If this query is given, you should compute the minimum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case, the minimum element of the first half of the sequence, {6,2,3,4} is 2.
3: The latter half of the sequence is elements that do not belong to the first half of the sequence. If this query is given, you should compute the minimum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case the answer for this query is 1 from {5,1,8}.
4: This query is given with an integer i. Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 2. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,3,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,1,8} The minimum element in the first half of the sequence is 2.
{6,1,8} The minimum element in the first half of the sequence is 1.
{6,8} The minimum element in the first half of the sequence is 6.
{8} The minimum element in the first half of the sequence is 8.
{} The first half of the sequence is empty.
For the initial state, {6,2,3,4} is the first half of the sequence. 2 and 6 become the minimum element of the first half of the sequence. In this example, the 1-st minimum element is 2 and the 2-nd is 6.
5: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 3. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,3,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,1,8} The minimum elemets in the latter half of the sequence is 8.
{6,8} The minimum elemets in the latter half of the sequence is 8.
{8} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {5,1,8} is the latter half of the sequence. 1 and 8 becomes the minimum element of the latter half ot the sequence. In this example, the 1-st minimum element is 1 and the 2-nd is 8.
6: If this query is given, you should compute the maximum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the first half of the sequence,{1,3,2,5}, is 5.
7: If this query is given, you should compute the maximum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the latter half of the sequence,{9,6,7}, is 9.
8: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 6. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the first half of the sequence is 5.
{1,3,2,9,6,7} The maximum element in the first half of the sequence is 3.
{1,3,9,6,7} The maximum element in the first half of the sequence is 9.
{1,3,6,7} The maximum element in the first half of the sequence is 3.
{1,6,7} The maximum element in the first half of the sequence is 6.
{1,7} The maximum element in the first half of the sequence is 1.
{7} The maximum element in the first half of the sequence is 7.
{} The first half of the sequence is empty.
For the initial state, {1,3,2,5} is the first half of the sequence. 1,3 and 5 becomes the maximum element of the first half of the sequence. In this example, the 1-st maximum element is 5, the 2-nd is 3 and the 3-rd is 1.
9: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 7. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,2,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,9,6,7} The maximum element in the latter half of the sequence is 7.
{1,3,6,7} The maximum element in the latter half of the sequence is 7.
{1,6,7} The maximum element in the latter half of the sequence is 7.
{1,7} The maximum element in the latter half of the sequence is 7.
{7} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {9,6,7} is the latter half of the sequence. 7 and 9 becomes the maximum element of the latter half of the sequence. In this example, the 1-st maximum element is 9 and the 2-nd is 7.
Input
Input consists of multiple test cases. The first line is the number of queries. Following q lines are queries.
q
query0
...
queryi
...
qurey_q-1
The sum of the number of queries in the input data is less than 200001. If queryi = 0, 4, 5, 8, and 9 are consists of pair of integers. Other queries are given with a single integer. You can assume that the length of the sequence doesn't exceed 20000.
Output
If the query is 0, you don't output any numbers. If the query is 1, you should output the deleted number. For other queries, you should output the computed value. For each case, you should output "end" (without quates) after you process all queries.
Example
Input
5
0 1
0 2
0 3
0 4
1
6
0 1
0 2
0 3
0 4
0 5
1
31
0 6
0 2
0 3
0 4
0 5
0 1
0 8
4 1
4 2
5 1
5 2
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
1
32
0 1
0 3
0 2
0 5
0 9
0 6
0 7
8 1
8 2
8 3
9 1
9 2
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
1
0
Output
2
end
3
end
2
6
1
8
2
1
4
2
1
3
2
1
5
2
1
2
1
8
1
6
8
6
8
8
end
5
3
1
9
7
5
9
5
3
9
2
9
7
9
3
7
3
6
7
6
1
7
1
7
7
end
Submitted Solution:
```
from collections import deque
def mid(qs):
m = len(qs)//2 if len(qs)%2 else len(qs)//2-1
return m
while True:
q = int(input())
if not q:
break
d = deque()
for _ in range(q):
query = input()
q1 = int(query[0])
# 0
if not q1:
d.append(int(query[2]))
# 1
elif q1 == 1:
i = mid(d)
d.remove(d[i])
# 2
elif q1 == 2:
i = mid(d)
print(min(d[i] for i in range(0, i+1)))
# 3
elif q1 == 3:
i = mid(d)
print(min(d[i] for i in range(i+1, len(d))))
# 4
elif q1 == 4:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
minv = []
while tmp:
i = mid(tmp)
l = min([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 5
elif q1 == 5:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
minv = []
while tmp:
i = mid(tmp)
print(tmp, i)
if len(tmp) == 1:
l = tmp[0]
else:
l = min([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 6
elif q1 == 6:
i = mid(d)
print(max(d[i] for i in range(0, i+1)))
# 7
elif q2 == 7:
i = mid(d)
print(max(d[i] for i in range(i+1, len(d))))
# 8
elif q1 == 8:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
maxv = []
while tmp:
i = mid(tmp)
l = max([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
# 9
else:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
maxv = []
while tmp:
i = mid(tmp)
if len(tmp) == 1:
l = tmp[0]
else:
l = max([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
print("end")
``` | instruction | 0 | 62,218 | 12 | 124,436 |
No | output | 1 | 62,218 | 12 | 124,437 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to simulate the sequence defined in the remaining part of the problem description.
This sequence is empty at first. i -th element of this sequence is expressed as ai . The first element of this sequence is a1 if the sequence is not empty. The operation is given by integer from 0 to 9. The operation is described below.
0: This query is given with some integer x. If this query is given, the integer x is inserted into the sequence. If the sequence is empty, a1 = x. If the sequence has n elements, an+1 = x. Same integer will not appear more than once as x.
1: If this query is given, one element in the sequence is deleted. The value in the middle of the sequence is deleted. If the sequence has n elements and n is even, an/2 will be deleted. If n is odd, a⌈n/2⌉ will be deleted. This query is not given when the sequence is empty. Assume that the sequence has a1 =1, a2 =2, a3 =3, a4 =4 and a5 =5. In this case, a3 will be deleted. After deletion, the sequence will be a1 =1, a2 =2, a3 =4, a4 =5. Assume that the sequence has a1 =1, a2 =2, a3 =3 and a4 =4, In this case, a2 will be deleted. After deletion, the sequence will be a1 =1, a2 =3, a3 =4.
2: The first half of the sequence is defined by the index from 1 to ⌈n/2⌉ . If this query is given, you should compute the minimum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case, the minimum element of the first half of the sequence, {6,2,3,4} is 2.
3: The latter half of the sequence is elements that do not belong to the first half of the sequence. If this query is given, you should compute the minimum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case the answer for this query is 1 from {5,1,8}.
4: This query is given with an integer i. Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 2. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,3,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,1,8} The minimum element in the first half of the sequence is 2.
{6,1,8} The minimum element in the first half of the sequence is 1.
{6,8} The minimum element in the first half of the sequence is 6.
{8} The minimum element in the first half of the sequence is 8.
{} The first half of the sequence is empty.
For the initial state, {6,2,3,4} is the first half of the sequence. 2 and 6 become the minimum element of the first half of the sequence. In this example, the 1-st minimum element is 2 and the 2-nd is 6.
5: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 3. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,3,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,1,8} The minimum elemets in the latter half of the sequence is 8.
{6,8} The minimum elemets in the latter half of the sequence is 8.
{8} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {5,1,8} is the latter half of the sequence. 1 and 8 becomes the minimum element of the latter half ot the sequence. In this example, the 1-st minimum element is 1 and the 2-nd is 8.
6: If this query is given, you should compute the maximum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the first half of the sequence,{1,3,2,5}, is 5.
7: If this query is given, you should compute the maximum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the latter half of the sequence,{9,6,7}, is 9.
8: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 6. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the first half of the sequence is 5.
{1,3,2,9,6,7} The maximum element in the first half of the sequence is 3.
{1,3,9,6,7} The maximum element in the first half of the sequence is 9.
{1,3,6,7} The maximum element in the first half of the sequence is 3.
{1,6,7} The maximum element in the first half of the sequence is 6.
{1,7} The maximum element in the first half of the sequence is 1.
{7} The maximum element in the first half of the sequence is 7.
{} The first half of the sequence is empty.
For the initial state, {1,3,2,5} is the first half of the sequence. 1,3 and 5 becomes the maximum element of the first half of the sequence. In this example, the 1-st maximum element is 5, the 2-nd is 3 and the 3-rd is 1.
9: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 7. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,2,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,9,6,7} The maximum element in the latter half of the sequence is 7.
{1,3,6,7} The maximum element in the latter half of the sequence is 7.
{1,6,7} The maximum element in the latter half of the sequence is 7.
{1,7} The maximum element in the latter half of the sequence is 7.
{7} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {9,6,7} is the latter half of the sequence. 7 and 9 becomes the maximum element of the latter half of the sequence. In this example, the 1-st maximum element is 9 and the 2-nd is 7.
Input
Input consists of multiple test cases. The first line is the number of queries. Following q lines are queries.
q
query0
...
queryi
...
qurey_q-1
The sum of the number of queries in the input data is less than 200001. If queryi = 0, 4, 5, 8, and 9 are consists of pair of integers. Other queries are given with a single integer. You can assume that the length of the sequence doesn't exceed 20000.
Output
If the query is 0, you don't output any numbers. If the query is 1, you should output the deleted number. For other queries, you should output the computed value. For each case, you should output "end" (without quates) after you process all queries.
Example
Input
5
0 1
0 2
0 3
0 4
1
6
0 1
0 2
0 3
0 4
0 5
1
31
0 6
0 2
0 3
0 4
0 5
0 1
0 8
4 1
4 2
5 1
5 2
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
1
32
0 1
0 3
0 2
0 5
0 9
0 6
0 7
8 1
8 2
8 3
9 1
9 2
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
1
0
Output
2
end
3
end
2
6
1
8
2
1
4
2
1
3
2
1
5
2
1
2
1
8
1
6
8
6
8
8
end
5
3
1
9
7
5
9
5
3
9
2
9
7
9
3
7
3
6
7
6
1
7
1
7
7
end
Submitted Solution:
```
from collections import deque
def mid(qs):
m = len(qs)//2 if len(qs)%2 else len(qs)//2-1
return m
while True:
q = int(input())
if not q:
break
d = deque()
for _ in range(q):
query = input()
q1 = int(query[0])
# 0
if not q1:
d.append(int(query[2]))
# 1
elif q1 == 1:
i = mid(d)
print(d[i])
d.remove(d[i])
# 2
elif q1 == 2:
i = mid(d)
print(min(d[i] for i in range(0, i+1)))
# 3
elif q1 == 3:
i = mid(d)
print(min(d[i] for i in range(i+1, len(d))))
# 4
elif q1 == 4:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
minv = []
while tmp:
i = mid(tmp)
l = min([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 5
elif q1 == 5:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
minv = []
while tmp:
i = mid(tmp)
print(tmp, i)
if len(tmp) == 1:
l = tmp[0]
else:
l = min([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 6
elif q1 == 6:
i = mid(d)
print(max(d[i] for i in range(0, i+1)))
# 7
elif q1 == 7:
i = mid(d)
print(max(d[i] for i in range(i+1, len(d))))
# 8
elif q1 == 8:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
maxv = []
while tmp:
i = mid(tmp)
l = max([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
# 9
else:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
maxv = []
while tmp:
i = mid(tmp)
if len(tmp) == 1:
l = tmp[0]
else:
l = max([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
print("end")
``` | instruction | 0 | 62,219 | 12 | 124,438 |
No | output | 1 | 62,219 | 12 | 124,439 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to simulate the sequence defined in the remaining part of the problem description.
This sequence is empty at first. i -th element of this sequence is expressed as ai . The first element of this sequence is a1 if the sequence is not empty. The operation is given by integer from 0 to 9. The operation is described below.
0: This query is given with some integer x. If this query is given, the integer x is inserted into the sequence. If the sequence is empty, a1 = x. If the sequence has n elements, an+1 = x. Same integer will not appear more than once as x.
1: If this query is given, one element in the sequence is deleted. The value in the middle of the sequence is deleted. If the sequence has n elements and n is even, an/2 will be deleted. If n is odd, a⌈n/2⌉ will be deleted. This query is not given when the sequence is empty. Assume that the sequence has a1 =1, a2 =2, a3 =3, a4 =4 and a5 =5. In this case, a3 will be deleted. After deletion, the sequence will be a1 =1, a2 =2, a3 =4, a4 =5. Assume that the sequence has a1 =1, a2 =2, a3 =3 and a4 =4, In this case, a2 will be deleted. After deletion, the sequence will be a1 =1, a2 =3, a3 =4.
2: The first half of the sequence is defined by the index from 1 to ⌈n/2⌉ . If this query is given, you should compute the minimum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case, the minimum element of the first half of the sequence, {6,2,3,4} is 2.
3: The latter half of the sequence is elements that do not belong to the first half of the sequence. If this query is given, you should compute the minimum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case the answer for this query is 1 from {5,1,8}.
4: This query is given with an integer i. Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 2. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,3,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,1,8} The minimum element in the first half of the sequence is 2.
{6,1,8} The minimum element in the first half of the sequence is 1.
{6,8} The minimum element in the first half of the sequence is 6.
{8} The minimum element in the first half of the sequence is 8.
{} The first half of the sequence is empty.
For the initial state, {6,2,3,4} is the first half of the sequence. 2 and 6 become the minimum element of the first half of the sequence. In this example, the 1-st minimum element is 2 and the 2-nd is 6.
5: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 3. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,3,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,1,8} The minimum elemets in the latter half of the sequence is 8.
{6,8} The minimum elemets in the latter half of the sequence is 8.
{8} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {5,1,8} is the latter half of the sequence. 1 and 8 becomes the minimum element of the latter half ot the sequence. In this example, the 1-st minimum element is 1 and the 2-nd is 8.
6: If this query is given, you should compute the maximum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the first half of the sequence,{1,3,2,5}, is 5.
7: If this query is given, you should compute the maximum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the latter half of the sequence,{9,6,7}, is 9.
8: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 6. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the first half of the sequence is 5.
{1,3,2,9,6,7} The maximum element in the first half of the sequence is 3.
{1,3,9,6,7} The maximum element in the first half of the sequence is 9.
{1,3,6,7} The maximum element in the first half of the sequence is 3.
{1,6,7} The maximum element in the first half of the sequence is 6.
{1,7} The maximum element in the first half of the sequence is 1.
{7} The maximum element in the first half of the sequence is 7.
{} The first half of the sequence is empty.
For the initial state, {1,3,2,5} is the first half of the sequence. 1,3 and 5 becomes the maximum element of the first half of the sequence. In this example, the 1-st maximum element is 5, the 2-nd is 3 and the 3-rd is 1.
9: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 7. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,2,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,9,6,7} The maximum element in the latter half of the sequence is 7.
{1,3,6,7} The maximum element in the latter half of the sequence is 7.
{1,6,7} The maximum element in the latter half of the sequence is 7.
{1,7} The maximum element in the latter half of the sequence is 7.
{7} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {9,6,7} is the latter half of the sequence. 7 and 9 becomes the maximum element of the latter half of the sequence. In this example, the 1-st maximum element is 9 and the 2-nd is 7.
Input
Input consists of multiple test cases. The first line is the number of queries. Following q lines are queries.
q
query0
...
queryi
...
qurey_q-1
The sum of the number of queries in the input data is less than 200001. If queryi = 0, 4, 5, 8, and 9 are consists of pair of integers. Other queries are given with a single integer. You can assume that the length of the sequence doesn't exceed 20000.
Output
If the query is 0, you don't output any numbers. If the query is 1, you should output the deleted number. For other queries, you should output the computed value. For each case, you should output "end" (without quates) after you process all queries.
Example
Input
5
0 1
0 2
0 3
0 4
1
6
0 1
0 2
0 3
0 4
0 5
1
31
0 6
0 2
0 3
0 4
0 5
0 1
0 8
4 1
4 2
5 1
5 2
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
1
32
0 1
0 3
0 2
0 5
0 9
0 6
0 7
8 1
8 2
8 3
9 1
9 2
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
1
0
Output
2
end
3
end
2
6
1
8
2
1
4
2
1
3
2
1
5
2
1
2
1
8
1
6
8
6
8
8
end
5
3
1
9
7
5
9
5
3
9
2
9
7
9
3
7
3
6
7
6
1
7
1
7
7
end
Submitted Solution:
```
from collections import deque
def mid(qs):
m = len(qs)//2 if len(qs)%2 else len(qs)//2-1
return m
while True:
q = int(input())
if not q:
break
d = deque()
for _ in range(q):
query = input()
q1 = int(query[0])
# 0
if not q1:
d.append(int(query[2]))
# 1
elif q1 == 1:
i = mid(d)
print(d[i])
d.remove(d[i])
# 2
elif q1 == 2:
i = mid(d)
print(min(d[i] for i in range(0, i+1)))
# 3
elif q1 == 3:
i = mid(d)
print(min(d[i] for i in range(i+1, len(d))))
# 4
elif q1 == 4:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
minv = []
while tmp:
i = mid(tmp)
l = min([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 5
elif q1 == 5:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
minv = []
while tmp:
i = mid(tmp)
print(tmp, i)
if len(tmp) == 1:
l = tmp[0]
else:
l = min([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 6
elif q1 == 6:
i = mid(d)
print(max(d[i] for i in range(0, i+1)))
# 7
elif q2 == 7:
i = mid(d)
print(max(d[i] for i in range(i+1, len(d))))
# 8
elif q1 == 8:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
maxv = []
while tmp:
i = mid(tmp)
l = max([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
# 9
else:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
maxv = []
while tmp:
i = mid(tmp)
if len(tmp) == 1:
l = tmp[0]
else:
l = max([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
print("end")
``` | instruction | 0 | 62,220 | 12 | 124,440 |
No | output | 1 | 62,220 | 12 | 124,441 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Your task is to simulate the sequence defined in the remaining part of the problem description.
This sequence is empty at first. i -th element of this sequence is expressed as ai . The first element of this sequence is a1 if the sequence is not empty. The operation is given by integer from 0 to 9. The operation is described below.
0: This query is given with some integer x. If this query is given, the integer x is inserted into the sequence. If the sequence is empty, a1 = x. If the sequence has n elements, an+1 = x. Same integer will not appear more than once as x.
1: If this query is given, one element in the sequence is deleted. The value in the middle of the sequence is deleted. If the sequence has n elements and n is even, an/2 will be deleted. If n is odd, a⌈n/2⌉ will be deleted. This query is not given when the sequence is empty. Assume that the sequence has a1 =1, a2 =2, a3 =3, a4 =4 and a5 =5. In this case, a3 will be deleted. After deletion, the sequence will be a1 =1, a2 =2, a3 =4, a4 =5. Assume that the sequence has a1 =1, a2 =2, a3 =3 and a4 =4, In this case, a2 will be deleted. After deletion, the sequence will be a1 =1, a2 =3, a3 =4.
2: The first half of the sequence is defined by the index from 1 to ⌈n/2⌉ . If this query is given, you should compute the minimum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case, the minimum element of the first half of the sequence, {6,2,3,4} is 2.
3: The latter half of the sequence is elements that do not belong to the first half of the sequence. If this query is given, you should compute the minimum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {6,2,3,4,5,1,8}. In this case the answer for this query is 1 from {5,1,8}.
4: This query is given with an integer i. Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 2. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,3,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,5,1,8} The minimum element in the first half of the sequence is 2.
{6,2,1,8} The minimum element in the first half of the sequence is 2.
{6,1,8} The minimum element in the first half of the sequence is 1.
{6,8} The minimum element in the first half of the sequence is 6.
{8} The minimum element in the first half of the sequence is 8.
{} The first half of the sequence is empty.
For the initial state, {6,2,3,4} is the first half of the sequence. 2 and 6 become the minimum element of the first half of the sequence. In this example, the 1-st minimum element is 2 and the 2-nd is 6.
5: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 3. You should compute the i -th minimum element from the answers. This query is not given when the sequence is empty. You can assume that i -th minimum element exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {6,2,3,4,5,1,8}.
{6,2,3,4,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,3,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,5,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,2,1,8} The minimum elemets in the latter half of the sequence is 1.
{6,1,8} The minimum elemets in the latter half of the sequence is 8.
{6,8} The minimum elemets in the latter half of the sequence is 8.
{8} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {5,1,8} is the latter half of the sequence. 1 and 8 becomes the minimum element of the latter half ot the sequence. In this example, the 1-st minimum element is 1 and the 2-nd is 8.
6: If this query is given, you should compute the maximum element of the first half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the first half of the sequence,{1,3,2,5}, is 5.
7: If this query is given, you should compute the maximum element of the latter half of the sequence. This query is not given when the sequence is empty.
Let me show an example.
Assume that the sequence is {1,3,2,5,9,6,7}. In this case, the maximum element of the latter half of the sequence,{9,6,7}, is 9.
8: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the first half of the sequence will become the answer for query 6. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the first half of the sequence is 5.
{1,3,2,9,6,7} The maximum element in the first half of the sequence is 3.
{1,3,9,6,7} The maximum element in the first half of the sequence is 9.
{1,3,6,7} The maximum element in the first half of the sequence is 3.
{1,6,7} The maximum element in the first half of the sequence is 6.
{1,7} The maximum element in the first half of the sequence is 1.
{7} The maximum element in the first half of the sequence is 7.
{} The first half of the sequence is empty.
For the initial state, {1,3,2,5} is the first half of the sequence. 1,3 and 5 becomes the maximum element of the first half of the sequence. In this example, the 1-st maximum element is 5, the 2-nd is 3 and the 3-rd is 1.
9: This query is given with an integer i . Assume that deletion is repeated until the sequence is empty. Some elements in the latter half of the sequence will become the answer for query 7. You should compute the i -th maximum element from the answers. This query is not given when the sequence is empty. You can assume that i -th maximum elements exists when this query is given.
Let me show an example.
Assume that deletion will be repeated to the sequence {1,3,2,5,9,6,7}.
{1,3,2,5,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,2,9,6,7} The maximum element in the latter half of the sequence is 9.
{1,3,9,6,7} The maximum element in the latter half of the sequence is 7.
{1,3,6,7} The maximum element in the latter half of the sequence is 7.
{1,6,7} The maximum element in the latter half of the sequence is 7.
{1,7} The maximum element in the latter half of the sequence is 7.
{7} The latter half of the sequence is empty.
{} The latter half of the sequence is empty.
For the initial state, {9,6,7} is the latter half of the sequence. 7 and 9 becomes the maximum element of the latter half of the sequence. In this example, the 1-st maximum element is 9 and the 2-nd is 7.
Input
Input consists of multiple test cases. The first line is the number of queries. Following q lines are queries.
q
query0
...
queryi
...
qurey_q-1
The sum of the number of queries in the input data is less than 200001. If queryi = 0, 4, 5, 8, and 9 are consists of pair of integers. Other queries are given with a single integer. You can assume that the length of the sequence doesn't exceed 20000.
Output
If the query is 0, you don't output any numbers. If the query is 1, you should output the deleted number. For other queries, you should output the computed value. For each case, you should output "end" (without quates) after you process all queries.
Example
Input
5
0 1
0 2
0 3
0 4
1
6
0 1
0 2
0 3
0 4
0 5
1
31
0 6
0 2
0 3
0 4
0 5
0 1
0 8
4 1
4 2
5 1
5 2
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
3
1
2
1
32
0 1
0 3
0 2
0 5
0 9
0 6
0 7
8 1
8 2
8 3
9 1
9 2
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
7
1
6
1
0
Output
2
end
3
end
2
6
1
8
2
1
4
2
1
3
2
1
5
2
1
2
1
8
1
6
8
6
8
8
end
5
3
1
9
7
5
9
5
3
9
2
9
7
9
3
7
3
6
7
6
1
7
1
7
7
end
Submitted Solution:
```
from collections import deque
def mid(qs):
m = len(qs)//2 if len(qs)%2 else len(qs)//2-1
return m
while True:
q = int(input())
if not q:
break
d = deque()
for _ in range(q):
query = input()
q1 = int(query[0])
# 0
if not q1:
d.append(int(query[2]))
# 1
elif q1 == 1:
i = mid(d)
print(d[i])
d.remove(d[i])
# 2
elif q1 == 2:
i = mid(d)
print(min(d[i] for i in range(0, i+1)))
# 3
elif q1 == 3:
i = mid(d)
print(min(d[i] for i in range(i+1, len(d))))
# 4
elif q1 == 4:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
minv = []
while tmp:
i = mid(tmp)
l = min([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 5
elif q1 == 5:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
minv = []
while tmp:
i = mid(tmp)
if len(tmp) == 1:
l = tmp[0]
else:
l = min([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in minv:
minv.append(l)
tmp.remove(tmp[i])
print(sorted(minv)[q2-1])
# 6
elif q1 == 6:
i = mid(d)
print(max(d[i] for i in range(0, i+1)))
# 7
elif q1 == 7:
i = mid(d)
print(max(d[i] for i in range(i+1, len(d))))
# 8
elif q1 == 8:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(0, i+1)]
maxv = []
while tmp:
i = mid(tmp)
l = max([tmp[i] for i in range(0, i+1)])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
# 9
else:
q2 = int(query[2])
tmp = d.copy()
i = mid(tmp)
candidatates = [d[i] for i in range(i+1, len(d))]
maxv = []
while tmp:
i = mid(tmp)
if len(tmp) == 1:
l = tmp[0]
else:
l = max([tmp[i] for i in range(i+1, len(tmp))])
if l in candidatates and l not in maxv:
maxv.append(l)
tmp.remove(tmp[i])
print(sorted(maxv, reverse=True)[q2-1])
print("end")
``` | instruction | 0 | 62,221 | 12 | 124,442 |
No | output | 1 | 62,221 | 12 | 124,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,424 | 12 | 124,848 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
a, b = list(map(int, input().strip().split(" ")))
c = [0] * b
m = 0
ans = []
for i in range(a):
y = int(input().strip())
c[y % b] += 1
while c[m % b] > (m/ b):
m += 1
ans.append(m)
print("\n".join(map(str, ans)))
``` | output | 1 | 62,424 | 12 | 124,849 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,425 | 12 | 124,850 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
class MinHeap:
class Node:
def __init__(self, i, key, priority):
self.i = i
self.key = key
self.priority = priority
def __repr__(self):
return "Node[i:{} k:{} p:{}]".format(
self.i, self.key, self.priority)
def sift_up(self, i):
while i > 0:
p = (i - 1) // 2
if self.heap[i].priority < self.heap[p].priority:
self.heap[i].i, self.heap[p].i = p, i
self.heap[i], self.heap[p] = self.heap[p], self.heap[i]
i = p
else:
break
def sift_down(self, i):
while 2 * i + 1 < len(self.heap):
m = i
l = 2 * i + 1
if self.heap[l].priority < self.heap[m].priority:
m = l
r = l + 1
if ( r < len(self.heap)
and self.heap[r].priority < self.heap[m].priority):
m = r
if m != i:
self.heap[i].i, self.heap[m].i = m, i
self.heap[i], self.heap[m] = self.heap[m], self.heap[i]
i = m
else:
break
def lowest_priority(self):
return self.heap[0].priority
def lowest_priority_key(self):
return self.heap[0].key
def get_priority(self, key):
return self.mapping[key].priority
def set_priority(self, key, new_priority):
node = self.mapping[key]
if new_priority < node.priority:
node.priority = new_priority
self.sift_up(node.i)
elif new_priority > node.priority:
node.priority = new_priority
self.sift_down(node.i)
def add_priority(self, key, priority):
node = self.Node(len(self.heap), key, priority)
self.mapping[key] = node
self.heap.append(node)
self.sift_up(len(self.heap) - 1)
def remove_priority(self, key):
node = self.mapping[key]
if node.i < len(self.heap) - 1:
replacement_node = self.heap.pop()
self.heap[node.i] = replacement_node
replacement_node.i = node.i
if replacement_node.priority < node.priority:
self.sift_up(node.i)
elif replacement_node.priority > node.priority:
self.sift_down(node.i)
else:
self.heap.pop()
del self.mapping[key]
def __init__(self, priorities={}):
if priorities is not None:
self.mapping = {}
self.heap = []
for key, priority in priorities.items():
node = self.Node(len(self.heap), key, priority)
self.mapping[key] = node
self.heap.append(node)
for i in range(len(self.heap) - 1, -1, -1):
self.sift_up(i)
def __len__(self):
return len(self.heap)
def __repr__(self):
return repr(self.heap)
import sys
q, x = (int(v) for v in sys.stdin.readline().split())
H = MinHeap({m: (0, m) for m in range(x)})
for i in range(q):
n = int(sys.stdin.readline())
m = n % x
mis_n, mis_m = H.get_priority(m)
H.set_priority(m, (mis_n + 1, mis_m))
mis_n, mis_m = H.lowest_priority()
print(mis_n * x + mis_m)
``` | output | 1 | 62,425 | 12 | 124,851 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,426 | 12 | 124,852 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
from collections import defaultdict as dd
from sys import stdin,stdout
input=stdin.readline
q,x=map(int,input().split())
a=[]
b=[0]*x
p=0
m=0
for _ in range(q):
i=int(input())
z=i%x
b[z]+=1
while b[p]>m:
p+=1
if p==x:
m+=1
p=0
stdout.write(str(m*x+p)+'\n')
``` | output | 1 | 62,426 | 12 | 124,853 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,427 | 12 | 124,854 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
# -*- coding: utf-8 -*-
# Baqir Khan
# Software Engineer (Backend)
from collections import defaultdict
from sys import stdin
inp = stdin.readline
q, x = map(int, inp().split())
freq = defaultdict(int)
ans = 0
while q:
q -= 1
a = int(inp())
freq[a % x] += 1
while freq[ans % x] > 0:
freq[ans % x] -= 1
ans += 1
print(ans)
``` | output | 1 | 62,427 | 12 | 124,855 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,428 | 12 | 124,856 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
q, x = [int(i) for i in input().split(' ')]
cc = [0] * x
mex = 0
res = []
for _ in range(q):
y = int(input())
y = y % x
cc[y] += 1
while cc[mex % x] > 0:
cc[mex % x] -= 1
mex += 1
res.append(str(mex))
print('\n'.join(res))
``` | output | 1 | 62,428 | 12 | 124,857 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,429 | 12 | 124,858 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
import sys
sys.setrecursionlimit(10**7)
fin = lambda: sys.stdin.readline()
fout = lambda args: sys.stdout.write(' '.join(str(i) for i in args) + '\n')
q, x = map(int, fin().split())
cnt = [0] * x
mex = 0
for _ in range(q):
a = int(fin())
cnt[a % x] += 1
while cnt[mex % x]:
cnt[mex % x] -= 1
mex += 1
fout([mex])
``` | output | 1 | 62,429 | 12 | 124,859 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,430 | 12 | 124,860 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
import math
from functools import reduce
n, x = map(int, input().split(' '))
ans = []
now = [0] * x
m = 0
for _ in range(n):
y = int(input())
now[y % x] += 1
while now[m % x] != 0:
now[m % x] -= 1
m += 1
ans.append(m)
print(*ans, sep=' ', end='\n')
#
``` | output | 1 | 62,430 | 12 | 124,861 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7. | instruction | 0 | 62,431 | 12 | 124,862 |
Tags: data structures, greedy, implementation, math
Correct Solution:
```
import sys
import math
from collections import defaultdict,Counter
input=sys.stdin.readline
def print(x):
sys.stdout.write(str(x)+"\n")
# sys.stdout=open("CP3/output.txt",'w')
# sys.stdin=open("CP3/input.txt",'r')
# m=pow(10,9)+7
st=set(range(4*10**5,-1,-1))
q,x=map(int,input().split())
v={}
p=0
for i in range(q):
y=int(input())
# if y in v:
# y+=v[y]*x
# v[y]+=1
# if y<=4*10**5:
# st.remove(y)
# else:
d=y//x
y-=d*x
if 0<=y<=4*10**5:
if y not in v:
v[y]=1
else:
y1=y
y+=v[y]*x
v[y1]+=1
# if y<=4*10**5:
st.discard(y)
while p not in st:
p+=1
print(p)
``` | output | 1 | 62,431 | 12 | 124,863 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
import heapq
import io, os
input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
q,x=list(map(int,input().split()))
lis=[0]*x
p=0
for j in range(q):
n=int(input())
r=n%x
lis[r]+=1
while lis[p%x]>0:
lis[p%x]-=1
p+=1
print(p)
``` | instruction | 0 | 62,432 | 12 | 124,864 |
Yes | output | 1 | 62,432 | 12 | 124,865 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
from sys import stdin, stdout
res = 0
d = [0 for i in range(400005)]
q, x = map(int, stdin.readline().split())
for _ in range(q):
n = int(stdin.readline())
d[n % x] += 1
while d[res % x] > res / x:
res += 1
print(res)
``` | instruction | 0 | 62,433 | 12 | 124,866 |
Yes | output | 1 | 62,433 | 12 | 124,867 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
# import sys
# file = open('test1')
# sys.stdin = file
def ii():
a = int(input())
return a
def ai():
a = list(map(int, input().split()))
return a
def mi():
a = map(int, input().split())
return a
q,x = mi()
mex = 0
freq = [0] * x
ans = []
for i in range(q):
freq[ii()%x] += 1
while freq[mex%x]>0:
freq[mex%x] -= 1
mex += 1
ans.append(mex)
print("\n".join(map(str, ans)))
``` | instruction | 0 | 62,434 | 12 | 124,868 |
Yes | output | 1 | 62,434 | 12 | 124,869 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
q, x = [int(i) for i in input().split(' ')]
cc = [0] * x
mex = 0
res = []
for _ in range(q):
y = int(input())
y = y % x
cc[y] += 1
while cc[mex % x] > 0:
cc[mex % x] -= 1
mex += 1
res.append(mex)
print('\n'.join(map(str, res)))
``` | instruction | 0 | 62,435 | 12 | 124,870 |
Yes | output | 1 | 62,435 | 12 | 124,871 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
q, x = map(int, input().split())
s = dict()
z = [0 for i in range(x)]
mex = 0
for i in range(q):
y = int(input())
if y % x in z:
z[y % x] += 1
else:
z[y % x] = 1
if y in s:
s[y] += 1
else:
s[y] = 1
a = y
while a == mex and a in s:
mex += 1
a += 1
newmex = mex
while 1:
if z[newmex % x] > newmex // x:
newmex += 1
else:
break
print(newmex)
``` | instruction | 0 | 62,436 | 12 | 124,872 |
No | output | 1 | 62,436 | 12 | 124,873 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
import sys
input = sys.stdin.readline
q,x = map(int,input().split())
Table = [0] * x
# THis is our table
# Value 0 1 2 3 4 5 .. x - 1
# How many encountered 0 0 0 0 0 0 .. 0
hunting = 0
for i in range(q):
val = int(input()) % x
Table[val] += 1
# max search x times (cyclic)
if(val == hunting): # Hoorayyy!!!!! We found what we are looking for
# Update the hunting and print the hunter
requirement = Table[val]
for it in range(hunting+1, hunting + x - 1):
if(it%x == 0):
requirement += 1
if(Table[it%x] != requirement):
hunting = it%x
break
hehe = (hunting - 1) % x
print((Table[hehe]-1) * x + hehe + 1)
continue
print(Table[hunting] * x + hunting)
``` | instruction | 0 | 62,437 | 12 | 124,874 |
No | output | 1 | 62,437 | 12 | 124,875 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
import os
import sys
from io import BytesIO, IOBase
# 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")
# ------------------------------
def RL(): return map(int, sys.stdin.readline().rstrip().split())
def RLL(): return list(map(int, sys.stdin.readline().rstrip().split()))
def N(): return int(input())
def comb(n, m): return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0
def perm(n, m): return factorial(n) // (factorial(n - m)) if n >= m else 0
def mdis(x1, y1, x2, y2): return abs(x1 - x2) + abs(y1 - y2)
def toord(c): return ord(c)-ord('a')
mod = 998244353
INF = float('inf')
from math import factorial, sqrt, ceil, floor
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush
# ------------------------------
# f = open('./input.txt')
# sys.stdin = f
def main():
q, x = RL()
hav = [0]*x
now = 0
res = []
for _ in range(q):
y = N()%x
hav[y]+=1
if y==x-1 and y==now%x: now+=1
while hav[now%x]>hav[(now+1)%x]:
now+=1
res.append(now%x + hav[now%x]*x)
for i in res:
print(i)
if __name__ == "__main__":
main()
``` | instruction | 0 | 62,438 | 12 | 124,876 |
No | output | 1 | 62,438 | 12 | 124,877 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Recall that MEX of an array is a minimum non-negative integer that does not belong to the array. Examples:
* for the array [0, 0, 1, 0, 2] MEX equals to 3 because numbers 0, 1 and 2 are presented in the array and 3 is the minimum non-negative integer not presented in the array;
* for the array [1, 2, 3, 4] MEX equals to 0 because 0 is the minimum non-negative integer not presented in the array;
* for the array [0, 1, 4, 3] MEX equals to 2 because 2 is the minimum non-negative integer not presented in the array.
You are given an empty array a=[] (in other words, a zero-length array). You are also given a positive integer x.
You are also given q queries. The j-th query consists of one integer y_j and means that you have to append one element y_j to the array. The array length increases by 1 after a query.
In one move, you can choose any index i and set a_i := a_i + x or a_i := a_i - x (i.e. increase or decrease any element of the array by x). The only restriction is that a_i cannot become negative. Since initially the array is empty, you can perform moves only after the first query.
You have to maximize the MEX (minimum excluded) of the array if you can perform any number of such operations (you can even perform the operation multiple times with one element).
You have to find the answer after each of q queries (i.e. the j-th answer corresponds to the array of length j).
Operations are discarded before each query. I.e. the array a after the j-th query equals to [y_1, y_2, ..., y_j].
Input
The first line of the input contains two integers q, x (1 ≤ q, x ≤ 4 ⋅ 10^5) — the number of queries and the value of x.
The next q lines describe queries. The j-th query consists of one integer y_j (0 ≤ y_j ≤ 10^9) and means that you have to append one element y_j to the array.
Output
Print the answer to the initial problem after each query — for the query j print the maximum value of MEX after first j queries. Note that queries are dependent (the array changes after each query) but operations are independent between queries.
Examples
Input
7 3
0
1
2
2
0
0
10
Output
1
2
3
3
4
4
7
Input
4 3
1
2
1
2
Output
0
0
0
0
Note
In the first example:
* After the first query, the array is a=[0]: you don't need to perform any operations, maximum possible MEX is 1.
* After the second query, the array is a=[0, 1]: you don't need to perform any operations, maximum possible MEX is 2.
* After the third query, the array is a=[0, 1, 2]: you don't need to perform any operations, maximum possible MEX is 3.
* After the fourth query, the array is a=[0, 1, 2, 2]: you don't need to perform any operations, maximum possible MEX is 3 (you can't make it greater with operations).
* After the fifth query, the array is a=[0, 1, 2, 2, 0]: you can perform a[4] := a[4] + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3]. Now MEX is maximum possible and equals to 4.
* After the sixth query, the array is a=[0, 1, 2, 2, 0, 0]: you can perform a[4] := a[4] + 3 = 0 + 3 = 3. The array changes to be a=[0, 1, 2, 2, 3, 0]. Now MEX is maximum possible and equals to 4.
* After the seventh query, the array is a=[0, 1, 2, 2, 0, 0, 10]. You can perform the following operations:
* a[3] := a[3] + 3 = 2 + 3 = 5,
* a[4] := a[4] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 0 + 3 = 3,
* a[5] := a[5] + 3 = 3 + 3 = 6,
* a[6] := a[6] - 3 = 10 - 3 = 7,
* a[6] := a[6] - 3 = 7 - 3 = 4.
The resulting array will be a=[0, 1, 2, 5, 3, 6, 4]. Now MEX is maximum possible and equals to 7.
Submitted Solution:
```
import sys
q,x = map(int,sys.stdin.readline().strip().split())
mxN = 4*(10**5)+1
mex = 0
a = {i:0 for i in range(x)}
need_to_mex = 0
mn = 0
needCheck = False
for query in range(q):
n = int(sys.stdin.readline().strip()) % x
a[n] += 1
if n == need_to_mex:
if needCheck:
mn = mxN
pos_mn = 0
for k in a:
if a[k] < mn:
mn = a[k]
pos_mn = k
need_to_mex = pos_mn
mex = mn*x + pos_mn
needCheck = False
else:
mex += 1
need_to_mex += 1
if need_to_mex >= x:
need_to_mex = 0
else:
needCheck = True
print(mex)
``` | instruction | 0 | 62,439 | 12 | 124,878 |
No | output | 1 | 62,439 | 12 | 124,879 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
John Doe has found the beautiful permutation formula.
Let's take permutation p = p1, p2, ..., pn. Let's define transformation f of this permutation:
<image>
where k (k > 1) is an integer, the transformation parameter, r is such maximum integer that rk ≤ n. If rk = n, then elements prk + 1, prk + 2 and so on are omitted. In other words, the described transformation of permutation p cyclically shifts to the left each consecutive block of length k and the last block with the length equal to the remainder after dividing n by k.
John Doe thinks that permutation f(f( ... f(p = [1, 2, ..., n], 2) ... , n - 1), n) is beautiful. Unfortunately, he cannot quickly find the beautiful permutation he's interested in. That's why he asked you to help him.
Your task is to find a beautiful permutation for the given n. For clarifications, see the notes to the third sample.
Input
A single line contains integer n (2 ≤ n ≤ 106).
Output
Print n distinct space-separated integers from 1 to n — a beautiful permutation of size n.
Examples
Input
2
Output
2 1
Input
3
Output
1 3 2
Input
4
Output
4 2 3 1
Note
A note to the third test sample:
* f([1, 2, 3, 4], 2) = [2, 1, 4, 3]
* f([2, 1, 4, 3], 3) = [1, 4, 2, 3]
* f([1, 4, 2, 3], 4) = [4, 2, 3, 1]
Submitted Solution:
```
def f(p, k):
result = []
for x in range(len(p) // k):
result.append(p[x * k + 1:(x + 1) * k])
result.append([p[x * k]])
result.append(p[(len(p) // k) * k + 1:])
if (len(p) // k) * k < len(p):
result.append([p[(len(p) // k) * k]])
merged = []
for r in result:
merged += r
return merged
class CodeforcesTask286BSolution:
def __init__(self):
self.result = ''
self.n = 0
def read_input(self):
self.n = int(input())
def process_task(self):
if self.n == 2:
self.result = "2 1"
elif self.n == 3:
self.result = "1 3 2"
else:
a0 = [x + 1 for x in range(self.n)]
a1 = f(a0, 2)
a2 = f(a1, self.n - 1)
a3 = f(a2, self.n)
for x in a3:
print(x, end=" ")
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask286BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | instruction | 0 | 62,626 | 12 | 125,252 |
No | output | 1 | 62,626 | 12 | 125,253 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.