message stringlengths 2 39.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 219 108k | cluster float64 11 11 | __index_level_0__ int64 438 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0
Submitted Solution:
```
x, y = map(int, input().split())
sum = 0
if x < 4:
sum += (4-x) * 100000
if y < 4:
sum += (4-y) * 100000
if x == 1 and y == 1:
sum += 4 * 100000
print(sum)
``` | instruction | 0 | 62,072 | 11 | 124,144 |
Yes | output | 1 | 62,072 | 11 | 124,145 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0
Submitted Solution:
```
a,b = map(int,input().split())
if a+b==2:
print(1000000)
else:
ans =0
if a<=3:
ans+= (4-a)*100000
if b<=3:
ans+= (4-a)*100000
print(ans)
``` | instruction | 0 | 62,073 | 11 | 124,146 |
No | output | 1 | 62,073 | 11 | 124,147 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0
Submitted Solution:
```
from sys import stdin
X,Y = [int(x) for x in stdin.readline().rstrip().split()]
if X == 1 and Y == 1:
print(300000*2 + 400000)
elif X == 1 or Y == 1:
print(300000)
elif X == 2 or Y == 2:
print(200000)
elif X == 3 or Y == 3:
print(100000)
else:
print(0)
``` | instruction | 0 | 62,074 | 11 | 124,148 |
No | output | 1 | 62,074 | 11 | 124,149 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0
Submitted Solution:
```
X, Y = map(int, input().split())
prices = {1: 300000, 2: 200000, 3: 1000000}
ans = 0
if X < 4:
ans += prices[X]
if Y < 4:
ans += prices[Y]
if Y == 1 and X == 1:
ans += 400000
print(ans)
``` | instruction | 0 | 62,075 | 11 | 124,150 |
No | output | 1 | 62,075 | 11 | 124,151 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We held two competitions: Coding Contest and Robot Maneuver.
In each competition, the contestants taking the 3-rd, 2-nd, and 1-st places receive 100000, 200000, and 300000 yen (the currency of Japan), respectively. Furthermore, a contestant taking the first place in both competitions receives an additional 400000 yen.
DISCO-Kun took the X-th place in Coding Contest and the Y-th place in Robot Maneuver. Find the total amount of money he earned.
Constraints
* 1 \leq X \leq 205
* 1 \leq Y \leq 205
* X and Y are integers.
Input
Input is given from Standard Input in the following format:
X Y
Output
Print the amount of money DISCO-Kun earned, as an integer.
Examples
Input
1 1
Output
1000000
Input
3 101
Output
100000
Input
4 4
Output
0
Submitted Solution:
```
x,y = map(int,input().split())
if x + y == 2:
print(1000000)
elif x + y == 3:
print(500000)
elif x + y == 5:
print(300000)
elif x + y == 4:
print(400000)
elif x + y == 6:
print(200000)
elif x + y >=5 and min(x,y) == 1:
print(300000)
elif x + y >=5 and min(x,y) == 2:
print(200000)
elif x + y >=5 and min(x,y) == 3:
print(1000000000)
else:
print(0)
``` | instruction | 0 | 62,076 | 11 | 124,152 |
No | output | 1 | 62,076 | 11 | 124,153 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,077 | 11 | 124,154 |
"Correct Solution:
```
n=int(input())
li=list(map(int,input().split()))
li.sort()
print(li[n//2]-li[n//2-1])
``` | output | 1 | 62,077 | 11 | 124,155 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,078 | 11 | 124,156 |
"Correct Solution:
```
n=int(input())
ds=list(map(int,input().split()))
ds.sort()
print(ds[n//2]-ds[n//2-1])
``` | output | 1 | 62,078 | 11 | 124,157 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,079 | 11 | 124,158 |
"Correct Solution:
```
n = int(input())
t = sorted(list(map(int, input().split())))
print(t[n//2] - t[n//2 - 1])
``` | output | 1 | 62,079 | 11 | 124,159 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,080 | 11 | 124,160 |
"Correct Solution:
```
n=int(input())
d=sorted(list(map(int,input().split())))
ans=d[n//2]-d[n//2-1]
print(ans)
``` | output | 1 | 62,080 | 11 | 124,161 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,081 | 11 | 124,162 |
"Correct Solution:
```
n=int(input())
L=sorted(list(map(int,input().split())))
print(L[n//2]-L[n//2-1])
``` | output | 1 | 62,081 | 11 | 124,163 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,082 | 11 | 124,164 |
"Correct Solution:
```
N = int(input())
d = list(sorted(map(int, input().split())))
print(d[N//2] - d[(N//2)-1])
``` | output | 1 | 62,082 | 11 | 124,165 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,083 | 11 | 124,166 |
"Correct Solution:
```
N=int(input())
d=list(map(int,input().split()))
d.sort()
ans=d[N//2]-d[N//2-1]
print(ans)
``` | output | 1 | 62,083 | 11 | 124,167 |
Provide a correct Python 3 solution for this coding contest problem.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685 | instruction | 0 | 62,084 | 11 | 124,168 |
"Correct Solution:
```
N=int(input())
d=list(map(int,input().split()))
d.sort()
l=d[N//2-1]
r=d[N//2]
print(r-l)
``` | output | 1 | 62,084 | 11 | 124,169 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
n=int(input())
*a,=sorted(map(int,input().split()))
m=len(a)//2
print(a[m]-a[m-1])
``` | instruction | 0 | 62,085 | 11 | 124,170 |
Yes | output | 1 | 62,085 | 11 | 124,171 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
n=int(input())
d=list(map(int,input().split()))
d.sort()
print(d[(n//2)]-d[(n//2)-1])
``` | instruction | 0 | 62,086 | 11 | 124,172 |
Yes | output | 1 | 62,086 | 11 | 124,173 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
N, *A = map(int, open(0).read().split())
A.sort()
ans = A[N//2] - A[N//2-1]
print(ans)
``` | instruction | 0 | 62,087 | 11 | 124,174 |
Yes | output | 1 | 62,087 | 11 | 124,175 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
n=int(input())
d=list(map(int,input().split()))
d=sorted(d)
m=n//2
print(d[m]-d[m-1])
``` | instruction | 0 | 62,088 | 11 | 124,176 |
Yes | output | 1 | 62,088 | 11 | 124,177 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
num = int(input())
seq = input().split()
sequence = [int(i) for i in seq]
count = 0
max_dif = max(sequence)
for i in range(max_dif):
a, b = 0, 0
for item in sequence:
if item>=i: a+=1
else: b+=1
if a==b: count+=1
print(count)
``` | instruction | 0 | 62,089 | 11 | 124,178 |
No | output | 1 | 62,089 | 11 | 124,179 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
N = int(input())
value = list(map(int,input().split()))
value.sort()
print(value)
print(value[(int(N/2))]-value[(int(N/2))-1])
``` | instruction | 0 | 62,090 | 11 | 124,180 |
No | output | 1 | 62,090 | 11 | 124,181 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
import numpy as np
n = int(input())
d = [int(i) for i in input().split(" ")]
uni = np.unique(d)
co = [d.count(i) for i in uni]
tm = 0
for i in range(n):
tm += co[i]
if tm == n//2:
print(uni[i+1]-uni[i])
break
if tm > n//2:
print(0)
break
``` | instruction | 0 | 62,091 | 11 | 124,182 |
No | output | 1 | 62,091 | 11 | 124,183 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Takahashi made N problems for competitive programming. The problems are numbered 1 to N, and the difficulty of Problem i is represented as an integer d_i (the higher, the harder).
He is dividing the problems into two categories by choosing an integer K, as follows:
* A problem with difficulty K or higher will be for ARCs.
* A problem with difficulty lower than K will be for ABCs.
How many choices of the integer K make the number of problems for ARCs and the number of problems for ABCs the same?
* 2 \leq N \leq 10^5
* N is an even number.
* 1 \leq d_i \leq 10^5
* All values in input are integers.
Input
Input is given from Standard Input in the following format:
N
d_1 d_2 ... d_N
Output
Print the number of choices of the integer K that make the number of problems for ARCs and the number of problems for ABCs the same.
Examples
Input
6
9 1 4 4 6 7
Output
2
Input
8
9 1 14 5 5 4 4 14
Output
0
Input
14
99592 10342 29105 78532 83018 11639 92015 77204 30914 21912 34519 80835 100000 1
Output
42685
Submitted Solution:
```
n = int(input())
a = tuple(map(int,input().split()))
a = sorted(a)
print(a[n//2+1]-a[n//2])
``` | instruction | 0 | 62,092 | 11 | 124,184 |
No | output | 1 | 62,092 | 11 | 124,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
_,*A=map(int,open(0).read().split());print(min(A[1::2])+max(A[::2]))
``` | instruction | 0 | 62,149 | 11 | 124,298 |
Yes | output | 1 | 62,149 | 11 | 124,299 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
N=int(input())
AB=[]
for i in range(N):
a,b=map(int,input().split())
AB.append([a,b])
AB.sort()
print(AB[-1][0]+AB[-1][1])
``` | instruction | 0 | 62,150 | 11 | 124,300 |
Yes | output | 1 | 62,150 | 11 | 124,301 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
N = int(input())
AB = [[int(i) for i in input().split()] for _ in range(N)]
AB.sort()
print(sum(AB[-1]))
``` | instruction | 0 | 62,151 | 11 | 124,302 |
Yes | output | 1 | 62,151 | 11 | 124,303 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
n = int(input())
ab = list(list(map(int,input().split())) for _ in range(n))
ab.sort()
print(ab[-1][0]+ab[-1][1])
``` | instruction | 0 | 62,152 | 11 | 124,304 |
Yes | output | 1 | 62,152 | 11 | 124,305 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
N = int(input())
ab = []
for i in range(N):
ab.append(tuple(map(int,input().split())))
ans = N
mx = max(ab,key=lambda x:x[1])[0]
ans += mx - 1
mn = min(ab,key=lambda x:x[1])[1]
ans += mn
print(ans)
``` | instruction | 0 | 62,153 | 11 | 124,306 |
No | output | 1 | 62,153 | 11 | 124,307 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
A group of people played a game. All players had distinct scores, which are positive integers.
Takahashi knows N facts on the players' scores. The i-th fact is as follows: the A_i-th highest score among the players is B_i.
Find the maximum possible number of players in the game.
Constraints
* 1 \leq N \leq 10^5
* 1 \leq A_i \leq 10^9(1\leq i\leq N)
* 0 \leq B_i \leq 10^9(1\leq i\leq N)
* If i β j, A_i β A_j.
* There exists a possible outcome of the game that are consistent with the facts.
* All input values are integers.
Inputs
Input is given from Standard Input in the following format:
N
A_1 B_1
:
A_N B_N
Outputs
Print the maximum possible number of players in the game.
Examples
Input
3
4 7
2 9
6 2
Output
8
Input
5
1 10
3 6
5 2
4 4
2 8
Output
7
Input
2
1 1000000000
1000000000 1
Output
1000000001
Submitted Solution:
```
#!user/bin/env python
# coding:utf-8
n = int(input())
info = []
for i in range(n):
ai = int(input())
bi = int(input())
info.append([ai, bi])
info = sorted(info, key=lambda inf: inf[1])
imp = info[0][0] + info[0][1]
print(imp)
``` | instruction | 0 | 62,154 | 11 | 124,308 |
No | output | 1 | 62,154 | 11 | 124,309 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
This problem was deleted from the contest, because it was used previously at another competition.
Input
Output
Examples
Input
1 1
1 2 100
Output
6
Submitted Solution:
```
n, m = map(int, input().split())
l, r, p = map(int, input().split())
def gcd(x,y):
if x == 0 or y == 0:
return max(x, y)
elif x > y:
return gcd(y, x % y)
elif x < y:
return gcd(x, y % x)
else:
return x
# ΠΎΠΏΡΠ΅Π΄Π΅Π»ΡΠ΅ΠΌ Π²ΠΎΠ·ΠΌΠΎΠΆΠ½ΡΠ΅ Π²Π΅ΠΊΡΠΎΡΠ° Π½Π°Π±Π»ΡΠ΄Π΅Π½ΠΈΡ
basis_vectors = set()
vectors = []
for i in range(1, r + 1):
for j in range(r + 1):
k = gcd(i, j)
x = i // k
y = j // k
if (x, y) not in basis_vectors:
basis_vectors.add((x,y))
if l ** 2 <= i ** 2 + j ** 2 <= r ** 2:
vectors.append((i,j))
# ΡΡΠΈΡΠ°Π΅ΠΌ ΠΏΠΎΠ»Π½ΠΎΠ΅ ΡΠΈΡΠ»ΠΎ ΠΏΠ°Ρ
pairs = 0
for x, y in vectors:
a = n + 1 - x
a = 0 if a < 0 else a
b = m + 1 - y
b = 0 if b < 0 else b
c = n + 1 - y
c = 0 if c < 0 else c
d = m + 1 - x
d = 0 if d < 0 else d
print(x,y)
print(a,b,c,d)
pairs += (a * b + c * d) % p
pairs = pairs % p
print(pairs)
``` | instruction | 0 | 62,670 | 11 | 125,340 |
No | output | 1 | 62,670 | 11 | 125,341 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
n=int(input())
if n%2!=0:
print('YES');lst=[1];mst=[];
for x in range(2,2*n+1,2):
if x%4==0:
lst.append(x);lst.append(x+1)
else:
mst.append(x);mst.append(x+1)
print(*lst,*mst[:n])
else:
print('NO')
``` | instruction | 0 | 63,229 | 11 | 126,458 |
Yes | output | 1 | 63,229 | 11 | 126,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
n=int(input())
if n%2==0:
print("NO")
exit()
print("YES")
t=1
dt=[3,1]
for i in range(n):
print(t,end=' ')
t+=dt[i%2]
t=2
dt=[1,3]
for i in range(n):
print(t,end=' ')
t+=dt[i%2]
exit()
import sys
n=1
a=list(range(1,2*n+1))
from itertools import permutations
for x in permutations(a):
x=x+x
b=[sum(x[i:i+n]) for i in range(2*n)]
if max(b)-min(b)<=1:
print(x)
``` | instruction | 0 | 63,230 | 11 | 126,460 |
Yes | output | 1 | 63,230 | 11 | 126,461 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
n = int(input())
if n % 2 == 0:
print("NO")
exit()
else:
arr = [0] * (2 * n)
k = 1
for i in range(1, n + 1):
if (i - 1) % 2 == 0:
arr[i - 1] = k
arr[i + n - 1] = k + 1
k += 1
else:
arr[i - 1] = k + 2
arr[i + n - 1] = k + 1
k += 3
print("YES")
print(*arr)
``` | instruction | 0 | 63,231 | 11 | 126,462 |
Yes | output | 1 | 63,231 | 11 | 126,463 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
N = int(input())
if N % 2 == 1:
print('YES')
saida = "1"
k = 3
ant = 1
for i in range(1, N):
saida += str(' ') + str(ant+k)
ant += k
if i % 2 == 1:
k = 1
else:
k = 3
saida += str(' 2')
k = 1
ant = 2
for i in range(1, N):
saida += str(' ') + str(ant+k)
ant += k
if i % 2 == 0:
k = 1
else:
k = 3
print(saida)
else:
print('NO')
``` | instruction | 0 | 63,232 | 11 | 126,464 |
Yes | output | 1 | 63,232 | 11 | 126,465 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
import math
import sys
input = sys.stdin.readline
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input().strip()
return(list(s[:len(s)]))
def invr():
return(map(int,input().split()))
n=inp()
if n%2==0:
print('NO')
else:
l=[0 for i in range(2*n)]
v=1
for i in range(0,len(l),2):
l[i]=(1+(n-1)*(i//2))%(2*n)
cnt=0
for i in range(n,n+len(l),2):
l[i%(2*n)]=(2+(n-1)*cnt)%(2*n)
if (2+(n-1)*cnt)%(2*n)==0:
l[i%(2*n)]=2*n
cnt+=1
print(*l)
``` | instruction | 0 | 63,233 | 11 | 126,466 |
No | output | 1 | 63,233 | 11 | 126,467 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
n = int(input())
if(n%2==0): print("NO")
else:
print("YES")
i = 1
while(i<2*n):
print(i,end=" ")
if(i%2==0): i+=1
else: i+=n
i = 2
while(i<=2*n):
print(i,end=" ")
if(i%2==0): i+=1
else: i+=n
``` | instruction | 0 | 63,234 | 11 | 126,468 |
No | output | 1 | 63,234 | 11 | 126,469 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
n=int(input())
a=[]
t=1
if(n%2==0):
print("NO")
else:
i=1
while(i<=2*n):
if(t==1):
a.append(i)
t=0
else:
a.append(i+1)
t=1
i+=2
n=len(a)
t=1
for i in range(n):
if(t==1):
a.append(a[i]+1)
t=0
else:
a.append(a[i]-1)
t=1
print(*a)
``` | instruction | 0 | 63,235 | 11 | 126,470 |
No | output | 1 | 63,235 | 11 | 126,471 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are given integer n. You have to arrange numbers from 1 to 2n, using each of them exactly once, on the circle, so that the following condition would be satisfied:
For every n consecutive numbers on the circle write their sum on the blackboard. Then any two of written on the blackboard 2n numbers differ not more than by 1.
For example, choose n = 3. On the left you can see an example of a valid arrangement: 1 + 4 + 5 = 10, 4 + 5 + 2 = 11, 5 + 2 + 3 = 10, 2 + 3 + 6 = 11, 3 + 6 + 1 = 10, 6 + 1 + 4 = 11, any two numbers differ by at most 1. On the right you can see an invalid arrangement: for example, 5 + 1 + 6 = 12, and 3 + 2 + 4 = 9, 9 and 12 differ more than by 1.
<image>
Input
The first and the only line contain one integer n (1 β€ n β€ 10^5).
Output
If there is no solution, output "NO" in the first line.
If there is a solution, output "YES" in the first line. In the second line output 2n numbers β numbers from 1 to 2n in the order they will stay in the circle. Each number should appear only once. If there are several solutions, you can output any of them.
Examples
Input
3
Output
YES
1 4 5 2 3 6
Input
4
Output
NO
Note
Example from the statement is shown for the first example.
It can be proved that there is no solution in the second example.
Submitted Solution:
```
#Bhargey Mehta (Junior)
#DA-IICT, Gandhinagar
import sys, math, queue
#sys.stdin = open('input.txt', 'r')
MOD = 998244353
sys.setrecursionlimit(1000000)
n = int(input())
i = 2
while i*i <= n:
if n%i == 0:
print('NO')
exit()
i += 1
x, y = [], []
s, p = 1, 2*n
for i in range(n):
if i%2 == 0:
x.append(s)
y.append(s+1)
s += 2
else:
x.append(p)
y.append(p-1)
p -= 2
ans = x+y
print('YES')
print(*ans)
``` | instruction | 0 | 63,236 | 11 | 126,472 |
No | output | 1 | 63,236 | 11 | 126,473 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
for i in range(int(input())):
n,x,t=map(int,input().split())
if t//x+1>=n:
print(n*(n-1)//2)
else:
a=t//x
sum=(n-a)*(a)+(a*(a-1))//2
print(sum)
``` | instruction | 0 | 63,394 | 11 | 126,788 |
Yes | output | 1 | 63,394 | 11 | 126,789 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
for _ in range(int(input())):
n,x,t=map(int,input().split())
each=min(n-1,t//x)
ans=(each-1)*(each)//2
print((each)*(n-each)+ans)
``` | instruction | 0 | 63,395 | 11 | 126,790 |
Yes | output | 1 | 63,395 | 11 | 126,791 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
from timeit import timeit
import os,sys
from datetime import datetime
from math import floor,sqrt,gcd,factorial
from collections import Counter,defaultdict
import bisect
from itertools import chain
from collections import deque
from sys import maxsize as INT_MAX
#import threading
'''Dont use setrecursionlimit in pypy'''
#sys.setrecursionlimit(int(1e9)+500)
#threading.stack_size(0x2000000)
INF=float('inf')
mod=int(1e9)+7
def readint():
return int(sys.stdin.readline())
def readstr():
return sys.stdin.readline()
def readlst():
return list(map(int, sys.stdin.readline().strip().split()))
def readmul():
return map(int, sys.stdin.readline().strip().split())
def mulfloat():
return map(float, sys.stdin.readline().strip().split())
def flush():
return sys.stdout.flush()
def power_two(x):
return (1<<x)
def lcm(a,b):
return a*b//gcd(a,b)
def ceil(a,b):
return(int((a+b-1)/b))
def countGreater(arr,n, k):
l = 0
r = n - 1
leftGreater = n
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
else:
l = m + 1
return (n - leftGreater)
def two_pointer(n,val,*arr):
l,r,cnt=0,n-1,0
while l<r:
if arr[l]+arr[r]>val:
r-=1
else:
cnt+=r-l
l+=1
return cnt
def lower(arr,n,val):
l,r=-1,n
while r>l+1:
m=int((l+r)>>1)
if arr[m]<val:
l=m
else:
r=m
return r
def upper(arr,n,val):
l,r=-1,n
while r>l+1:
m=int((l+r)>>1)
if arr[m]<=val:
l=m
else:
r=m
return l
def BFS(adj, src, dist, paths, n):
visited = [False] * n
dist[src] = 0
paths[src] = 1
q = deque()
q.append(src)
visited[src] = True
while q:
curr = q[0]
#print('q at start',q)
q.popleft()
for x in adj[curr]:
#print('x',x)
if not visited[x]:
q.append(x)
#print('q after append',q)
visited[x] = True
if dist[x] > dist[curr] + 1:
dist[x] = dist[curr] + 1
paths[x] = (paths[curr])%mod
elif dist[x] == dist[curr] + 1:
paths[x] =(paths[x]%mod+paths[curr]%mod)%mod
def binpow(a,n,mod):
res=1
while n:
if n&1:
res=(res*a)%mod
n-=1
a=(a*a)%mod
n=n>>1
return res
'''
c-space = to copy
o-space= to open file
,-space=to run prog
:noh= to get rid of text highlight
'''
def is_perfect_square(num):
#print(num)
temp = num**(0.5)
#print(temp)
return (temp//1)==temp
def printmat(l):
for i in range(0,len(l)):
print(*l[i],sep="")
print()
'''
1. Implement after understanding properly don't do in vain
2. Check corner cases
'''
def omkar():
n,x,t=readmul()
print(max(0,n-t//x)*(t//x)+min(n-1,(t//x)-1)*min(n,(t//x))//2)
return
def main():
tc=readint()
#test=1
while tc:
omkar()
tc-=1
main()
``` | instruction | 0 | 63,396 | 11 | 126,792 |
Yes | output | 1 | 63,396 | 11 | 126,793 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
for _ in range(int(input())):
f,q,j=map(int,input().split())
ans=min(f-1,j//q)
if ans==0 :
print(0)
else:
finalsol=max(0,ans*(ans-1)//2)+ans*(f-ans)
print(finalsol)
``` | instruction | 0 | 63,397 | 11 | 126,794 |
Yes | output | 1 | 63,397 | 11 | 126,795 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
for _ in range(int(input())):
n,x,t = [int(x) for x in input().split()]
c = t//x
ans = c*(n-c) + (((c-1)*c)//2)
print(ans)
``` | instruction | 0 | 63,398 | 11 | 126,796 |
No | output | 1 | 63,398 | 11 | 126,797 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
t=int(input())
for i in range(t):
n,x,t=map(int,input().split())
if n==1:
print(0)
elif t<x:
print(0)
elif t==x:
print(n-1)
else:
ans=0
a=t//x
ans+=(n-a)*a
f=a
f-=1
ans+=(f*(f+1))//2
print(ans)
``` | instruction | 0 | 63,399 | 11 | 126,798 |
No | output | 1 | 63,399 | 11 | 126,799 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
import sys
import math
import random
from collections import deque, defaultdict
#print = sys.stdout.write
from string import ascii_letters
letters = ascii_letters[:26].upper()
ONLINE_JUDGE = 0
from functools import lru_cache
if any(['--local' in i for i in sys.argv]) and not ONLINE_JUDGE:
sys.stdin = open('input.txt', 'r', encoding='utf-8')
#sys.stdin = open('27887.txt', 'r')
sys.stdout = open('output.txt', 'w', encoding='utf-8')
for _ in range(int(input())):
n, x, t = map(int, input().split())
v = t // x
res = 0
res += v * (n - v)
res += (0 + min(n, v) - 1) * min(n, v) // 2
print(res)
``` | instruction | 0 | 63,400 | 11 | 126,800 |
No | output | 1 | 63,400 | 11 | 126,801 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third β at time 2 β
x, and so on.
Duration of contest is t minutes for each participant, so the first participant finishes the contest at time t, the second β at time t + x, and so on. When a participant finishes the contest, their dissatisfaction equals to the number of participants that started the contest (or starting it now), but haven't yet finished it.
Determine the sum of dissatisfaction of all participants.
Input
The first line contains a single integer k (1 β€ k β€ 1000) β the number of test cases.
Each of the next k lines contains three integers n, x, t (1 β€ n, x, t β€ 2 β
10^9) β the number of participants, the start interval and the contest duration.
Output
Print k lines, in the i-th line print the total dissatisfaction of participants in the i-th test case.
Example
Input
4
4 2 5
3 1 2
3 3 10
2000000000 1 2000000000
Output
5
3
3
1999999999000000000
Note
In the first example the first participant starts at 0 and finishes at time 5. By that time the second and the third participants start, so the dissatisfaction of the first participant is 2.
The second participant starts at time 2 and finishes at time 7. By that time the third the fourth participants start, so the dissatisfaction of the second participant is 2.
The third participant starts at 4 and finishes at 9. By that time the fourth participant starts, so the dissatisfaction of the third participant is 1.
The fourth participant starts at 6 and finishes at 11. By time 11 everyone finishes the contest, so the dissatisfaction of the fourth participant is 0.
In the second example the first participant starts at 0 and finishes at time 2. By that time the second participants starts, and the third starts at exactly time 2. So the dissatisfaction of the first participant is 2.
The second participant starts at time 1 and finishes at time 3. At that time the third participant is solving the contest.
Submitted Solution:
```
for t in range(int(input())):
n,x, k = map(int, input().split())
v = k//x
if(n>=v):
c = (v)*(n-v) + (v)*(v -1)/2
else:
c = n*(n-1)//2
print(c)
``` | instruction | 0 | 63,401 | 11 | 126,802 |
No | output | 1 | 63,401 | 11 | 126,803 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,577 | 11 | 127,154 |
Tags: binary search, greedy, math
Correct Solution:
```
n = int(input())
c, d = [], []
for i in range(n) :
ci, di = map(int, input().split())
c.append(ci), d.append(di)
s = [0] * (n + 1)
geq, leq = 0, 0
for i in reversed(range(n)) :
s[i] = s[i + 1] + c[i]
if d[i] == 1 :
if geq == 0 :
g = s[i] + 1900
else :
g = max(g, s[i] + 1900)
geq += 1
elif d[i] == 2 :
if leq == 0 :
l = s[i] + 1899
else :
l = min(s[i] + 1899, l)
leq += 1
if leq == 0 :
print("Infinity")
elif geq == 0 or g <= l :
print(l)
else :
print("Impossible")
``` | output | 1 | 63,577 | 11 | 127,155 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,578 | 11 | 127,156 |
Tags: binary search, greedy, math
Correct Solution:
```
n = int(input())
INF = 2 ** 60
lo, hi = -INF, INF
for i in range(n):
x, y = (int(_) for _ in input().split())
if y == 2:
hi = min(hi, 1899)
else:
lo = max(lo, 1900)
hi += x
lo += x
if lo > hi:
print('Impossible')
elif hi > 2 ** 31:
print('Infinity')
else:
print(hi)
``` | output | 1 | 63,578 | 11 | 127,157 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,579 | 11 | 127,158 |
Tags: binary search, greedy, math
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
import math
import itertools
import bisect
import heapq
#sys.setrecursionlimit(300000)
def main():
pass
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 binary(n):
return (bin(n).replace("0b", ""))
def decimal(s):
return (int(s, 2))
def pow2(n):
p = 0
while (n > 1):
n //= 2
p += 1
return (p)
def primeFactors(n):
l = []
while n % 2 == 0:
l.append(2)
n = n / 2
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
l.append(i)
n = n / i
if n > 2:
l.append(int(n))
return (l)
def isPrime(n):
if (n == 1):
return (False)
else:
root = int(n ** 0.5)
root += 1
for i in range(2, root):
if (n % i == 0):
return (False)
return (True)
def maxPrimeFactors(n):
maxPrime = -1
while n % 2 == 0:
maxPrime = 2
n >>= 1
for i in range(3, int(math.sqrt(n)) + 1, 2):
while n % i == 0:
maxPrime = i
n = n / i
if n > 2:
maxPrime = n
return int(maxPrime)
def countcon(s, i):
c = 0
ch = s[i]
for i in range(i, len(s)):
if (s[i] == ch):
c += 1
else:
break
return (c)
def lis(arr):
n = len(arr)
lis = [1] * n
for i in range(1, n):
for j in range(0, i):
if arr[i] > arr[j] and lis[i] < lis[j] + 1:
lis[i] = lis[j] + 1
maximum = 0
for i in range(n):
maximum = max(maximum, lis[i])
return maximum
def isSubSequence(str1, str2):
m = len(str1)
n = len(str2)
j = 0
i = 0
while j < m and i < n:
if str1[j] == str2[i]:
j = j + 1
i = i + 1
return j == m
def maxfac(n):
root = int(n ** 0.5)
for i in range(2, root + 1):
if (n % i == 0):
return (n // i)
return (n)
def p2(n):
c=0
while(n%2==0):
n//=2
c+=1
return c
def seive(n):
primes=[True]*(n+1)
primes[1]=primes[0]=False
for i in range(2,n+1):
if(primes[i]):
for j in range(i+i,n+1,i):
primes[j]=False
p=[]
for i in range(0,n+1):
if(primes[i]):
p.append(i)
return(p)
def ncr(n, r, p):
num = den = 1
for i in range(r):
num = (num * (n - i)) % p
den = (den * (i + 1)) % p
return (num * pow(den,
p - 2, p)) % p
def denofactinverse(n,m):
fac=1
for i in range(1,n+1):
fac=(fac*i)%m
return (pow(fac,m-2,m))
def numofact(n,m):
fac=1
for i in range(1,n+1):
fac=(fac*i)%m
return(fac)
n=int(input())
div1,div2=-10**18,10**18
for i in range(0,n):
c,d=map(int,input().split())
if(d==2):
div2=min(div2,1899)
else:
div1=max(div1,1900)
div1+=c
div2+=c
if(div2>=div1):
if(div2>10**10):
print("Infinity")
else:
print(div2)
else:
print("Impossible")
``` | output | 1 | 63,579 | 11 | 127,159 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,580 | 11 | 127,160 |
Tags: binary search, greedy, math
Correct Solution:
```
s, t = -10 ** 8, 10 ** 8
for i in range(int(input())):
c, d = map(int, input().split())
if d == 1:
s = max(s, 1900)
else:
t = min(t, 1899)
# print(s,t)
if s > t:
print('Impossible')
exit()
s, t = s + c, t + c
print('Infinity' if t > 5 * 10 ** 7 else t)
``` | output | 1 | 63,580 | 11 | 127,161 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,581 | 11 | 127,162 |
Tags: binary search, greedy, math
Correct Solution:
```
#!/usr/local/bin/python3.4
import pdb
def A1B2(LIST):
flag = False
for (a,b) in LIST:
if b == 1:
flag = True
if flag and b==2:
return False
return True
def A2B2(LIST):
a,b = LIST[0]
for i in range(1,len(LIST)):
c,d = LIST[i]
if ( b== 2 and d ==1):
return a
a,b =c,d
def calc(N):
curent_value=0
first, second =map (int, input().split() )
cont=list()
cont.append( ( 0 , second ))
old_change = first
current_value = 0
last_value= first
for _ in range(N - 1 ):
change, division = map( int, input().split() )
current_value += old_change
cont.append( (current_value, division) )
old_change = change
last_value = current_value + change
# pbd.set_trace()
# print (last_value)
sort_cont = (sorted(cont))
a, b = sort_cont[-1]
if (all( b == 1 for (a,b) in sort_cont)):
return "Infinity"
if (all ( b == 2 for (a,b) in sort_cont)):
a, b = sort_cont[-1]
# pdb.set_trace()
return (1899 - a + last_value )
if not A1B2(sort_cont):
return "Impossible"
if len(sort_cont) == 0 :
return (1899 - first)
else:
return ( 1899 - A2B2(sort_cont) + last_value )
N = int(input())
print (calc(N))
``` | output | 1 | 63,581 | 11 | 127,163 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Every Codeforces user has rating, described with one integer, possibly negative or zero. Users are divided into two divisions. The first division is for users with rating 1900 or higher. Those with rating 1899 or lower belong to the second division. In every contest, according to one's performance, his or her rating changes by some value, possibly negative or zero.
Limak competed in n contests in the year 2016. He remembers that in the i-th contest he competed in the division di (i.e. he belonged to this division just before the start of this contest) and his rating changed by ci just after the contest. Note that negative ci denotes the loss of rating.
What is the maximum possible rating Limak can have right now, after all n contests? If his rating may be arbitrarily big, print "Infinity". If there is no scenario matching the given information, print "Impossible".
Input
The first line of the input contains a single integer n (1 β€ n β€ 200 000).
The i-th of next n lines contains two integers ci and di ( - 100 β€ ci β€ 100, 1 β€ di β€ 2), describing Limak's rating change after the i-th contest and his division during the i-th contest contest.
Output
If Limak's current rating can be arbitrarily big, print "Infinity" (without quotes). If the situation is impossible, print "Impossible" (without quotes). Otherwise print one integer, denoting the maximum possible value of Limak's current rating, i.e. rating after the n contests.
Examples
Input
3
-7 1
5 2
8 2
Output
1907
Input
2
57 1
22 2
Output
Impossible
Input
1
-5 1
Output
Infinity
Input
4
27 2
13 1
-50 1
8 2
Output
1897
Note
In the first sample, the following scenario matches all information Limak remembers and has maximum possible final rating:
* Limak has rating 1901 and belongs to the division 1 in the first contest. His rating decreases by 7.
* With rating 1894 Limak is in the division 2. His rating increases by 5.
* Limak has rating 1899 and is still in the division 2. In the last contest of the year he gets + 8 and ends the year with rating 1907.
In the second sample, it's impossible that Limak is in the division 1, his rating increases by 57 and after that Limak is in the division 2 in the second contest. | instruction | 0 | 63,582 | 11 | 127,164 |
Tags: binary search, greedy, math
Correct Solution:
```
n=int(input())
mx=10**9
mn=-10**9
r=0
for i in range(n):
c,d=[int(j) for j in input().split()]
if d==1:
mn=max(mn,1900-r)
else:
mx=min(mx,1899-r)
r+=c
if mx==10**9:
print("Infinity")
elif mn>mx:
print("Impossible")
else:
print(mx+r)
``` | output | 1 | 63,582 | 11 | 127,165 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.