message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,793 | 3 | 143,586 |
Tags: math
Correct Solution:
```
def main():
for _ in range(int(input())):
x1, x2, a, b = map(int,input().split())
print((x2 - x1) // (a + b) if (x2 - x1) % (a + b) == 0 else -1)
main()
``` | output | 1 | 71,793 | 3 | 143,587 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,794 | 3 | 143,588 |
Tags: math
Correct Solution:
```
for _ in range(int(input())):
s, e, a, b = [int(x) for x in input().split()]
distance = e - s
perunit = a + b
time, rest = divmod(distance, perunit)
if rest == 0:
print(time)
else:
print(-1)
``` | output | 1 | 71,794 | 3 | 143,589 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,795 | 3 | 143,590 |
Tags: math
Correct Solution:
```
n = int(input())
for ii in range(n):
x, y, a, b = map(int, input().split())
x = y - x
a = a + b
print((x//a,-1)[x%a>0])
``` | output | 1 | 71,795 | 3 | 143,591 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward. | instruction | 0 | 71,796 | 3 | 143,592 |
Tags: math
Correct Solution:
```
T=int(input())
while T>0:
x,y,a,b=map(int,input().split())
if (y-x)%(a+b)==0:
print((y-x)//(a+b))
else:
print(-1)
T-=1
``` | output | 1 | 71,796 | 3 | 143,593 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
# print("Input number of test cases")
t = int(input())
for i in range(t):
# print("Input x, y, a, and b")
x,y,a,b = [int(x) for x in input().split()]
if (y-x)%(a+b) == 0:
print((y-x)//(a+b))
else:
print(-1)
``` | instruction | 0 | 71,797 | 3 | 143,594 |
Yes | output | 1 | 71,797 | 3 | 143,595 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
t = int(input())
for _ in range(t):
x,y,a,b = map(int,input().split())
p = y - x
q = a + b
if p%q==0:
print(p//q)
else:
print(-1)
``` | instruction | 0 | 71,798 | 3 | 143,596 |
Yes | output | 1 | 71,798 | 3 | 143,597 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
t = int(input())
for i in range(t):
x,y,a,b=map(int, input().split())
print((y-x)//(a+b) if (y-x)%(a+b)==0 else -1)
``` | instruction | 0 | 71,799 | 3 | 143,598 |
Yes | output | 1 | 71,799 | 3 | 143,599 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
n = int(input())
Result = []
for i in range (0,n):
List = list(map(int, input().strip().split()))[:4]
x = List[0]
y = List[1]
diff = y - x
a = List[2]
b = List[3]
if diff % (a+b) == 0:
Result.append(int(diff/(a+b)))
else:
Result.append(-1)
for i in Result:
print(i)
``` | instruction | 0 | 71,800 | 3 | 143,600 |
Yes | output | 1 | 71,800 | 3 | 143,601 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
t = int(input("give the number of cases"))
li=[]
for i in range(t):
li.append(input("donner les condition initial"))
for i in range(t):
li_of_cond = li[i].split(" ")
if (int(li_of_cond[1])-int(li_of_cond[0]))% (int(li_of_cond[2])+int(li_of_cond[3])) ==0 :
time = (int(li_of_cond[1])-int(li_of_cond[0]))// (int(li_of_cond[2])+int(li_of_cond[3]))
print(time)
else :
print("-1")
``` | instruction | 0 | 71,801 | 3 | 143,602 |
No | output | 1 | 71,801 | 3 | 143,603 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
for _ in range(int(input())):
x=0
q=0
a,b,c,d=input().split()
a,b,c,d=int(a),int(b),int(c),int(d)
if (a+b)%(c+d)==0:
while a<b:
a+=c
b-=d
x+=1
if a==b:
q=1
break
print(x)
else:
print(-1)
``` | instruction | 0 | 71,802 | 3 | 143,604 |
No | output | 1 | 71,802 | 3 | 143,605 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
t=int(input())
for i in range(t):
x,y,a,b=[int(i) for i in input().split()]
m=y
for j in range(1,m):
x=x+a
y=y-b
if x==y:
print(j)
break
elif x>y:
print(-1)
break
``` | instruction | 0 | 71,803 | 3 | 143,606 |
No | output | 1 | 71,803 | 3 | 143,607 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Being tired of participating in too many Codeforces rounds, Gildong decided to take some rest in a park. He sat down on a bench, and soon he found two rabbits hopping around. One of the rabbits was taller than the other.
He noticed that the two rabbits were hopping towards each other. The positions of the two rabbits can be represented as integer coordinates on a horizontal line. The taller rabbit is currently on position x, and the shorter rabbit is currently on position y (x < y). Every second, each rabbit hops to another position. The taller rabbit hops to the positive direction by a, and the shorter rabbit hops to the negative direction by b.
<image>
For example, let's say x=0, y=10, a=2, and b=3. At the 1-st second, each rabbit will be at position 2 and 7. At the 2-nd second, both rabbits will be at position 4.
Gildong is now wondering: Will the two rabbits be at the same position at the same moment? If so, how long will it take? Let's find a moment in time (in seconds) after which the rabbits will be at the same point.
Input
Each test contains one or more test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000).
Each test case contains exactly one line. The line consists of four integers x, y, a, b (0 ≤ x < y ≤ 10^9, 1 ≤ a,b ≤ 10^9) — the current position of the taller rabbit, the current position of the shorter rabbit, the hopping distance of the taller rabbit, and the hopping distance of the shorter rabbit, respectively.
Output
For each test case, print the single integer: number of seconds the two rabbits will take to be at the same position.
If the two rabbits will never be at the same position simultaneously, print -1.
Example
Input
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Output
2
-1
10
-1
1
Note
The first case is explained in the description.
In the second case, each rabbit will be at position 3 and 7 respectively at the 1-st second. But in the 2-nd second they will be at 6 and 4 respectively, and we can see that they will never be at the same position since the distance between the two rabbits will only increase afterward.
Submitted Solution:
```
n = int(input())
w1 = 0
w2 = 0
wt = 0
for i in range(0, n):
x, y, a, b = map(int,input().split())
w1 = a + b #v
w2 = abs(y - x) #d
wt = w2 / w1 #t
if wt % 2 > 0 and wt < 1:
print(-1)
elif wt % 2 > 1 and wt < 2:
print(-1)
elif wt % 2 == 0:
print(int(wt))
elif wt % 2 == 1:
print(int(wt))
``` | instruction | 0 | 71,804 | 3 | 143,608 |
No | output | 1 | 71,804 | 3 | 143,609 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
for i in range(int(input())):
x=int(input())
y=0
i=1
while(y<x):
y += i
i += 1
if(y==x+1):
print(i)
else:
print(i-1)
``` | instruction | 0 | 71,862 | 3 | 143,724 |
Yes | output | 1 | 71,862 | 3 | 143,725 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
suma=0
t=1
while suma<n:
suma+=t
t+=1
t-=1
#print("ini jawabannya ", end="")
if suma==n:
print(t)
else:
if suma-n==1:
print(t+1)
else:
print(t)
``` | instruction | 0 | 71,863 | 3 | 143,726 |
Yes | output | 1 | 71,863 | 3 | 143,727 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
for _ in range(int(input())):
n=int(input())
y=0
while n>0:
y+=1
n-=y
if n==-1:
y+=1
print(y)
``` | instruction | 0 | 71,864 | 3 | 143,728 |
Yes | output | 1 | 71,864 | 3 | 143,729 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
for j in range(int(input())):
a=int(input())
i,sum=1,0
for i in range(1,a+1):
sum+=i
if sum>=a:
break
if a!=sum-1:
print(i)
else:
print(i+1)
``` | instruction | 0 | 71,865 | 3 | 143,730 |
Yes | output | 1 | 71,865 | 3 | 143,731 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Nov 30 14:32:40 2020
"""
t = int(input())
for _ in range(t):
x = int(input())
n = 0
while n*(n+1)/2 < x:
n+= 1
print(n)
``` | instruction | 0 | 71,866 | 3 | 143,732 |
No | output | 1 | 71,866 | 3 | 143,733 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
t=int(input())
for i in range(t):
x=int(input())
n=1
while True:
sum=n*(n+1)/2
if x==sum:
print(int(n))
break
elif x>sum:
n+=1
elif x<sum:
print(int(n+(sum-x)))
break
``` | instruction | 0 | 71,867 | 3 | 143,734 |
No | output | 1 | 71,867 | 3 | 143,735 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
t = int(input())
for i in range(t):
a = int(input())
y = []
for j in range(10 * 6 + 1):
c = -j
p = 1 + j
while c < a:
c += p
p += 1
if c == a:
y.append(p - 1)
else:
y.append((p - 1) + (c - a))
y.sort()
if y[-1] - y[0] > 20:
break
print(y[0])
``` | instruction | 0 | 71,868 | 3 | 143,736 |
No | output | 1 | 71,868 | 3 | 143,737 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
You are standing on the OX-axis at point 0 and you want to move to an integer point x > 0.
You can make several jumps. Suppose you're currently at point y (y may be negative) and jump for the k-th time. You can:
* either jump to the point y + k
* or jump to the point y - 1.
What is the minimum number of jumps you need to reach the point x?
Input
The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.
The first and only line of each test case contains the single integer x (1 ≤ x ≤ 10^6) — the destination point.
Output
For each test case, print the single integer — the minimum number of jumps to reach x. It can be proved that we can reach any integer point x.
Example
Input
5
1
2
3
4
5
Output
1
3
2
3
4
Note
In the first test case x = 1, so you need only one jump: the 1-st jump from 0 to 0 + 1 = 1.
In the second test case x = 2. You need at least three jumps:
* the 1-st jump from 0 to 0 + 1 = 1;
* the 2-nd jump from 1 to 1 + 2 = 3;
* the 3-rd jump from 3 to 3 - 1 = 2;
Two jumps are not enough because these are the only possible variants:
* the 1-st jump as -1 and the 2-nd one as -1 — you'll reach 0 -1 -1 =-2;
* the 1-st jump as -1 and the 2-nd one as +2 — you'll reach 0 -1 +2 = 1;
* the 1-st jump as +1 and the 2-nd one as -1 — you'll reach 0 +1 -1 = 0;
* the 1-st jump as +1 and the 2-nd one as +2 — you'll reach 0 +1 +2 = 3;
In the third test case, you need two jumps: the 1-st one as +1 and the 2-nd one as +2, so 0 + 1 + 2 = 3.
In the fourth test case, you need three jumps: the 1-st one as -1, the 2-nd one as +2 and the 3-rd one as +3, so 0 - 1 + 2 + 3 = 4.
Submitted Solution:
```
t = int(input())
d = [1]
for i in range(1, 3000):
d.append(d[i - 1] + i + 1)
n = len(d) - 1
for _ in range(t):
x = int(input())
if x > 3:
l = 0
r = n
while l < r:
m = l + (r - l) // 2
if d[m] <= x:
l = m + 1
if d[m] == x:
upper = m
if l < len(d) and d[l] == x:
upper = l
else:
r = m
if d[l] - 1 == x:
print(l + 2)
else:
print(l + 1)
elif x == 1:
print(1)
elif x == 2:
print(3)
elif x == 3:
print(2)
``` | instruction | 0 | 71,869 | 3 | 143,738 |
No | output | 1 | 71,869 | 3 | 143,739 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,967 | 3 | 143,934 |
Tags: brute force
Correct Solution:
```
n=int(input())
l=0
a={}
for i in range(n):
x,y=map(int,input().split())
a[x]=x+y
for j in a:
try:
if j==a[a[j]]:
print("YES")
break
else:
l+=1
except:
l+=1
continue
if l==len(a):
print("NO")
``` | output | 1 | 71,967 | 3 | 143,935 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,968 | 3 | 143,936 |
Tags: brute force
Correct Solution:
```
def solve():
n = int(input())
camels = {}
for i in range(n):
x, d = [int(s) for s in input().split(' ')]
camels[x] = d
for c in camels:
y = c + camels[c]
if y in camels and camels[y] == -camels[c]:
return "YES"
return "NO"
print(solve())
``` | output | 1 | 71,968 | 3 | 143,937 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,969 | 3 | 143,938 |
Tags: brute force
Correct Solution:
```
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_int_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read integers
get_int = lambda: int(sys.stdin.readline())
#to print fast
pt = lambda x: sys.stdout.write(str(x)+'\n')
#--------------------------------WhiteHat010--------------------------------------#
n = get_int()
d = {}
for _ in range(n):
a,b = get_int_list()
d[a] = a+b
flag = False
for k,v in d.items():
if v in d and d[v] == k:
flag = True
break
if flag:
print("YES")
else:
print("NO")
``` | output | 1 | 71,969 | 3 | 143,939 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,970 | 3 | 143,940 |
Tags: brute force
Correct Solution:
```
n = int(input())
Distancias = [0]*n
Posiciones = [0]*n
for k in range (n):
L = input()
L = L.split()
P = int(L[0])
d = int(L[1])
Distancias[k]=P+d
Posiciones[k]=P
Aux = 0
for k in range (n):
for i in range (n):
if Posiciones[k]==Distancias[i]:
if Posiciones[i]==Distancias[k]:
Aux =1
if Aux ==1:
print('YES')
else:
print('NO')
``` | output | 1 | 71,970 | 3 | 143,941 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,971 | 3 | 143,942 |
Tags: brute force
Correct Solution:
```
n = int(input())
x = [0]*n
d = [0]*n
for i in range(n):
x[i],d[i] = map(int,input().split())
for i in range(n):
if x[i] + d[i] in x and d[x.index(x[i] + d[i])] + x[i] + d[i] == x[i]: print("YES"); exit()
print("NO")
``` | output | 1 | 71,971 | 3 | 143,943 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,972 | 3 | 143,944 |
Tags: brute force
Correct Solution:
```
n = int(input())
cont, ans = {}, 'NO'
for i in range(n):
pos, spit = [int(item) for item in input().split(' ')]
cont[pos] = spit
for pos in cont:
secondCamel = pos + cont[pos]
if secondCamel in cont and secondCamel + cont[secondCamel] == pos:
ans = 'YES'
break
print(ans)
``` | output | 1 | 71,972 | 3 | 143,945 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,973 | 3 | 143,946 |
Tags: brute force
Correct Solution:
```
n = int(input())
x = [0]*n
d = [0]*n
for i in range(n):
xi, di = map(int,input().split())
x[i] = xi
d[i] = di
for i in range(n):
for j in range(i+1,n):
if x[i] + d[i] == x[j] and x[j] + d[j] == x[i]:
print("YES")
exit()
print("NO")
``` | output | 1 | 71,973 | 3 | 143,947 |
Provide tags and a correct Python 3 solution for this coding contest problem.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES | instruction | 0 | 71,974 | 3 | 143,948 |
Tags: brute force
Correct Solution:
```
v=[]
v1=[]
s=0
for i in range(int(input())):
x,d=map(int,input().split())
v.append(x)
v1.append(d)
for x in range(len(v)):
for y in range(x+1,len(v)):
if v[x]+v1[x] == v[y] and v[y]+v1[y] == v[x]:
print('YES')
s=1
break
if s==1:
break
if s==0:
print('NO')
``` | output | 1 | 71,974 | 3 | 143,949 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
N = int(input())
X = []
for n in range(N):
p, d = map(int, input().split())
X += [[p, d]]
f = False
for i in range(N - 1):
for j in range(i + 1, N):
if X[i][0] + X[i][1] == X[j][0] and X[j][0] + X[j][1] == X[i][0]:
f = True
break
if f:
print("YES")
else:
print("NO")
``` | instruction | 0 | 71,975 | 3 | 143,950 |
Yes | output | 1 | 71,975 | 3 | 143,951 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
n = int(input())
pos = []
can = False
for i in range(n):
pos.append(list(map(int, input().split())))
for i in range(n-1):
curr = pos[i][0] + pos[i][1]
for j in range(i,n):
curr1 = pos[j][0] + pos[j][1]
if curr == pos[j][0] and curr1 == pos[i][0]:
can = True
break
if can :
print("YES")
else:
print("NO")
``` | instruction | 0 | 71,976 | 3 | 143,952 |
Yes | output | 1 | 71,976 | 3 | 143,953 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
n = int(input())
x = []
d = []
x_d = []
for i in range(n):
a,b = map(int,input().split())
x.append(a)
d.append(b)
x_d.append(a+b)
for i in range(n):
for j in range(n):
done=False
if x_d[j]==x[i]:
if x[j]==x_d[i]:
print("YES")
done=True
break
if done==True:
break
if done==False:
print("NO")
``` | instruction | 0 | 71,977 | 3 | 143,954 |
Yes | output | 1 | 71,977 | 3 | 143,955 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
n = int(input())
x = list()
d = list()
count = False
for i in range(n):
s, t = map(int, input().split())
x.append(s)
d.append(t)
for i in range(n):
for j in range(n):
if i != j:
if x[i]+d[i] == x[j] and x[j]+d[j] == x[i]:
count = True
if count == True:
print("YES")
if count == False:
print("NO")
``` | instruction | 0 | 71,978 | 3 | 143,956 |
Yes | output | 1 | 71,978 | 3 | 143,957 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
import sys
import math
#to read string
get_string = lambda: sys.stdin.readline().strip()
#to read list of integers
get_int_list = lambda: list( map(int,sys.stdin.readline().strip().split()) )
#to read integers
get_int = lambda: int(sys.stdin.readline())
#to print fast
pt = lambda x: sys.stdout.write(str(x)+'\n')
#--------------------------------WhiteHat010--------------------------------------#
n = get_int()
d = {}
for _ in range(n):
a,b = get_int_list()
d[a] = a+b
flag = False
for k,v in d.items():
if v in d and d[v] + v == k:
flag = True
break
if flag:
print("YES")
else:
print("NO")
``` | instruction | 0 | 71,979 | 3 | 143,958 |
No | output | 1 | 71,979 | 3 | 143,959 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
n = int(input())
xl = []
dl = []
hm = [0]*100000
for i in range(n):
x,d = map(int,input().split())
xl.append(x)
dl.append(d)
hm[x]=1
c = 0
f = 1
for i in range(n):
if(hm[xl[i]+dl[i]] == 1):
c+=1
if(c>=2):
f = 0
print('YES')
break
if(f):
print('NO')
``` | instruction | 0 | 71,980 | 3 | 143,960 |
No | output | 1 | 71,980 | 3 | 143,961 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
N = int(input())
arr = []
for i in range(N):
j = input().split()
for i2 in range(2):
j[i2] = int(j[i2])
arr.append(j)
ans = "NO"
counter = 0
for i in range(N - 1):
if arr[i][0] + arr[i][1] == arr[i+1][0] and arr[i+1][0] + arr[i+1][1] == arr[i][0]:
ans = "YES"
print(ans)
``` | instruction | 0 | 71,981 | 3 | 143,962 |
No | output | 1 | 71,981 | 3 | 143,963 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In a Berland's zoo there is an enclosure with camels. It is known that camels like to spit. Bob watched these interesting animals for the whole day and registered in his notepad where each animal spitted. Now he wants to know if in the zoo there are two camels, which spitted at each other. Help him to solve this task.
The trajectory of a camel's spit is an arc, i.e. if the camel in position x spits d meters right, he can hit only the camel in position x + d, if such a camel exists.
Input
The first line contains integer n (1 ≤ n ≤ 100) — the amount of camels in the zoo. Each of the following n lines contains two integers xi and di ( - 104 ≤ xi ≤ 104, 1 ≤ |di| ≤ 2·104) — records in Bob's notepad. xi is a position of the i-th camel, and di is a distance at which the i-th camel spitted. Positive values of di correspond to the spits right, negative values correspond to the spits left. No two camels may stand in the same position.
Output
If there are two camels, which spitted at each other, output YES. Otherwise, output NO.
Examples
Input
2
0 1
1 -1
Output
YES
Input
3
0 1
1 1
2 -2
Output
NO
Input
5
2 -10
3 10
0 5
5 -5
10 1
Output
YES
Submitted Solution:
```
def calrange(x, d):
if d>=0:
return [x, x+d]
else: return [x+d, x]
n=int(input())
x=[]
d=[]
r=[]
b=[]
c=0
for i in range(n):
tx, td=[int(x) for x in input().split()]
x.append(tx), d.append(td)
r.append(calrange(tx, td))
for i in range(n):
for j in range(n):
if i!=j and c==0:
if r[i][0]<=x[j]<=r[i][1]:
b.insert(j, i)
if j in b:
if b[i]==b.index(i):
print("YES")
c=1
if c==0: print("NO")
``` | instruction | 0 | 71,982 | 3 | 143,964 |
No | output | 1 | 71,982 | 3 | 143,965 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n beacons located at distinct positions on a number line. The i-th beacon has position ai and power level bi. When the i-th beacon is activated, it destroys all beacons to its left (direction of decreasing coordinates) within distance bi inclusive. The beacon itself is not destroyed however. Saitama will activate the beacons one at a time from right to left. If a beacon is destroyed, it cannot be activated.
Saitama wants Genos to add a beacon strictly to the right of all the existing beacons, with any position and any power level, such that the least possible number of beacons are destroyed. Note that Genos's placement of the beacon means it will be the first beacon activated. Help Genos by finding the minimum number of beacons that could be destroyed.
Input
The first line of input contains a single integer n (1 ≤ n ≤ 100 000) — the initial number of beacons.
The i-th of next n lines contains two integers ai and bi (0 ≤ ai ≤ 1 000 000, 1 ≤ bi ≤ 1 000 000) — the position and power level of the i-th beacon respectively. No two beacons will have the same position, so ai ≠ aj if i ≠ j.
Output
Print a single integer — the minimum number of beacons that could be destroyed if exactly one beacon is added.
Examples
Input
4
1 9
3 1
6 1
7 4
Output
1
Input
7
1 1
2 1
3 1
4 1
5 1
6 1
7 1
Output
3
Note
For the first sample case, the minimum number of beacons destroyed is 1. One way to achieve this is to place a beacon at position 9 with power level 2.
For the second sample case, the minimum number of beacons destroyed is 3. One way to achieve this is to place a beacon at position 1337 with power level 42.
Submitted Solution:
```
from bisect import bisect_left
n=int(input())
arr=[list(map(int,input().split())) for j in range(n)]
arr.sort()
pos=[i[0] for i in arr]
pre=[0]
for i in range(1,n):
ind=bisect_left(pos,arr[i][0]-arr[i][1])
pre.append(i-ind+pre[max(0,ind-1)])
ans=pre[-1]
#print(pre)
d=0
for i in range(n-1,0,-1):
d+=1
ans=min(ans,d+pre[i-1])
print(ans)
``` | instruction | 0 | 72,092 | 3 | 144,184 |
Yes | output | 1 | 72,092 | 3 | 144,185 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Tyndex is again well ahead of the rivals! The reaction to the release of Zoozle Chrome browser was the release of a new browser Tyndex.Brome!
The popularity of the new browser is growing daily. And the secret is not even the Tyndex.Bar installed (the Tyndex.Bar automatically fills the glass with the finest 1664 cognac after you buy Tyndex.Bottles and insert in into a USB port). It is highly popular due to the well-thought interaction with the user.
Let us take, for example, the system of automatic address correction. Have you entered codehorses instead of codeforces? The gloomy Zoozle Chrome will sadly say that the address does not exist. Tyndex.Brome at the same time will automatically find the closest address and sent you there. That's brilliant!
How does this splendid function work? That's simple! For each potential address a function of the F error is calculated by the following rules:
* for every letter ci from the potential address c the closest position j of the letter ci in the address (s) entered by the user is found. The absolute difference |i - j| of these positions is added to F. So for every i (1 ≤ i ≤ |c|) the position j is chosen such, that ci = sj, and |i - j| is minimal possible.
* if no such letter ci exists in the address entered by the user, then the length of the potential address |c| is added to F.
After the values of the error function have been calculated for all the potential addresses the most suitable one is found.
To understand the special features of the above described method better, it is recommended to realize the algorithm of calculating the F function for an address given by the user and some set of potential addresses. Good luck!
Input
The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 105). They are the number of potential addresses and the length of the address entered by the user. The next line contains k lowercase Latin letters. They are the address entered by the user (s). Each next i-th (1 ≤ i ≤ n) line contains a non-empty sequence of lowercase Latin letters. They are the potential address. It is guaranteed that the total length of all the lines does not exceed 2·105.
Output
On each n line of the output file print a single number: the value of the error function when the current potential address is chosen.
Please, do not use %lld specificator to read or write 64-bit integers in C++. It is preffered to use cout (also you may use %I64d).
Examples
Input
2 10
codeforces
codeforces
codehorses
Output
0
12
Input
9 9
vkontakte
vcontacte
vkontrakte
vkollapse
vkrokodile
vtopke
vkapuste
vpechke
vk
vcodeforcese
Output
18
14
36
47
14
29
30
0
84
Submitted Solution:
```
import string
n, k = map(int, input().split())
given = input().strip()
letters = { ch: [] for ch in string.ascii_lowercase }
for pos, ch in enumerate(given):
letters[ch].append(pos)
for i in range(n):
candidate = input().strip()
error = 0
for a, ch in enumerate(candidate):
distance = len(candidate)
for b in letters[ch]:
distance = min(distance, abs(a - b))
error += distance
print(error)
``` | instruction | 0 | 72,104 | 3 | 144,208 |
No | output | 1 | 72,104 | 3 | 144,209 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
N = int(input())
T = [0] + list(map(int, input().split()))
V = [0] + list(map(int, input().split()))
left = [0] * (N + 1)
right = [0] * (N + 1)
for i in range(1, N):
start = left[i - 1]
left[i] = min(start + T[i], V[i], V[i + 1])
for i in range(N - 1, 0, -1):
start = right[i + 1]
right[i] = min(start + T[i + 1], V[i], V[i + 1])
total = [min(left[i], right[i]) for i in range(N + 1)]
ans = 0
for i in range(1, N + 1):
x = (V[i] - total[i - 1]) + (V[i] - total[i])
if x >= T[i]:
V[i] = (total[i - 1] + T[i] + total[i]) / 2
x = T[i]
d =(total[i - 1] + V[i]) * (V[i] - total[i - 1]) / 2 #台形左側
d += (total[i] + V[i]) * (V[i] - total[i]) / 2 #台形右側
d += V[i] * (T[i] - x) #真ん中の定速部分
ans += d
print (ans)
``` | instruction | 0 | 72,376 | 3 | 144,752 |
Yes | output | 1 | 72,376 | 3 | 144,753 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split()))
v = list(map(int, input().split()))
v.insert(0, 0)
v.append(0)
l = [0, 0]
r = [0]
for i in range(n):
l.append(l[i+1]+t[i])
r.append(l[i+2])
r.append(r[n])
d = 0
vl = 0
for k in range(l[n+1]*2):
now = k / 2 + 0.5
vr = 1000
for i in range(n+2):
tv = 0
if now < l[i]:
tv = v[i] + l[i] - now
elif now < r[i]:
tv = v[i]
else:
tv = v[i] + now - r[i]
vr = min(vr, tv)
d += (vl+vr) * 0.25
vl = vr
print(d)
``` | instruction | 0 | 72,377 | 3 | 144,754 |
Yes | output | 1 | 72,377 | 3 | 144,755 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda :sys.stdin.readline().rstrip()
def resolve():
n=int(input())
T=[0]+list(map(int,input().split()))
for i in range(n): T[i+1]+=T[i]
V=list(map(int,input().split()))
def f(t):
res=INF
res=min(res,t)
res=min(res,-t+T[-1])
for i in range(1,n+1):
if(t<T[i-1]): res=min(res,-t+T[i-1]+V[i-1])
elif(t<=T[i]): res=min(res,V[i-1])
else: res=min(res,t-T[i]+V[i-1])
return res
ans=0
for t in range(2*T[-1]): # 0.5刻みで計算
ans+=(f(t/2)+f((t+1)/2))/4
print(ans)
resolve()
``` | instruction | 0 | 72,378 | 3 | 144,756 |
Yes | output | 1 | 72,378 | 3 | 144,757 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
n = int(input())
T = list(map(int,input().split()))
V = list(map(int,input().split()))
b = 2
bg = 1.0 / b
M = [] #t = i秒の最高速度
for i in range(n) :
for j in range(T[i] * b) :
M.append(V[i])
R = [0] + T[:]
for i in range(n) :
R[i+1] += R[i]
for i in range(n) :
le = R[i] * b
ri = R[i+1] * b
j = 0
if i-1 >= 0 and V[i-1] > V[i] :
while le >= 0 :
M[le] = min(M[le], V[i] + j*bg)
#print(M[le])
j += 1
le -= 1
j = 0
if i+1 < n and V[i+1] > V[i] :
while ri < len(M) :
M[ri] = min(M[ri], V[i] + j*bg)
j += 1
ri += 1
for i in range(len(M)) :
M[i] = min(i*bg, (len(M)-i)*bg, M[i])
M += [0]
ans = 0
for i in range(len(M)-1) :
ans += (M[i] + M[i+1]) * bg * 0.5
print(ans)
``` | instruction | 0 | 72,379 | 3 | 144,758 |
Yes | output | 1 | 72,379 | 3 | 144,759 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
# -*- coding: utf-8 -*-
#############
# Libraries #
#############
import sys
input = sys.stdin.readline
import math
#from math import gcd
import bisect
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
#############
# Constants #
#############
MOD = 10**9+7
INF = float('inf')
AZ = "abcdefghijklmnopqrstuvwxyz"
#############
# Functions #
#############
######INPUT######
def I(): return int(input().strip())
def S(): return input().strip()
def IL(): return list(map(int,input().split()))
def SL(): return list(map(str,input().split()))
def ILs(n): return list(int(input()) for _ in range(n))
def SLs(n): return list(input().strip() for _ in range(n))
def ILL(n): return [list(map(int, input().split())) for _ in range(n)]
def SLL(n): return [list(map(str, input().split())) for _ in range(n)]
######OUTPUT######
def P(arg): print(arg); return
def Y(): print("Yes"); return
def N(): print("No"); return
def E(): exit()
def PE(arg): print(arg); exit()
def YE(): print("Yes"); exit()
def NE(): print("No"); exit()
#####Shorten#####
def DD(arg): return defaultdict(arg)
#####Inverse#####
def inv(n): return pow(n, MOD-2, MOD)
######Combination######
kaijo_memo = []
def kaijo(n):
if(len(kaijo_memo) > n): return kaijo_memo[n]
if(len(kaijo_memo) == 0): kaijo_memo.append(1)
while(len(kaijo_memo) <= n): kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
return kaijo_memo[n]
gyaku_kaijo_memo = []
def gyaku_kaijo(n):
if(len(gyaku_kaijo_memo) > n): return gyaku_kaijo_memo[n]
if(len(gyaku_kaijo_memo) == 0): gyaku_kaijo_memo.append(1)
while(len(gyaku_kaijo_memo) <= n): gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
return gyaku_kaijo_memo[n]
def nCr(n,r):
if n == r: return 1
if n < r or r < 0: return 0
ret = 1
ret = ret * kaijo(n) % MOD
ret = ret * gyaku_kaijo(r) % MOD
ret = ret * gyaku_kaijo(n-r) % MOD
return ret
######Factorization######
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1: arr.append([temp, 1])
if arr==[]: arr.append([n, 1])
return arr
#####MakeDivisors######
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
#####MakePrimes######
def make_primes(N):
max = int(math.sqrt(N))
seachList = [i for i in range(2,N+1)]
primeNum = []
while seachList[0] <= max:
primeNum.append(seachList[0])
tmp = seachList[0]
seachList = [i for i in seachList if i % tmp != 0]
primeNum.extend(seachList)
return primeNum
#####GCD#####
def gcd(a, b):
while b: a, b = b, a % b
return a
#####LCM#####
def lcm(a, b):
return a * b // gcd (a, b)
#####BitCount#####
def count_bit(n):
count = 0
while n:
n &= n-1
count += 1
return count
#####ChangeBase#####
def base_10_to_n(X, n):
if X//n: return base_10_to_n(X//n, n)+[X%n]
return [X%n]
def base_n_to_10(X, n):
return sum(int(str(X)[-i-1])*n**i for i in range(len(str(X))))
def base_10_to_n_without_0(X, n):
X -= 1
if X//n: return base_10_to_n_without_0(X//n, n)+[X%n]
return [X%n]
#####IntLog#####
def int_log(n, a):
count = 0
while n>=a:
n //= a
count += 1
return count
#############
# Main Code #
#############
def ACC1(l):
N = len(l)
ret = [0]*(N+1)
for i in range(N):
ret[i+1] = ret[i]+l[i]
return ret
N = I()
T = IL()
V = IL()
ACCT = ACC1(T)
TALL = sum(T)
Lspeed = [None for i in range(TALL*2+1)]
Lspeed[0] = 0
for i in range(N):
start_time = ACCT[i]
vmax = V[i]
if i != N-1:
next_vmax = V[i+1]
else:
next_vmax = 0
for j in range(1,T[i]*2+1):
Lspeed[start_time*2+j] = min(Lspeed[start_time*2]+j/2,next_vmax+T[i]-j/2,vmax)
ans = 0
for i in range(TALL*2):
ans += Lspeed[i]+Lspeed[i+1]
print(ans/4)
``` | instruction | 0 | 72,380 | 3 | 144,760 |
No | output | 1 | 72,380 | 3 | 144,761 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
from itertools import accumulate as ac
n=int(input())+2
t=[0]+list(map(int,input().split()))+[0]
v=[0]+list(map(int,input().split()))+[0]
s=[0]+list(ac(t))
def f(i,x):
if s[i]<=x<=s[i]+t[i]:return v[i]
elif x<s[i]:return v[i]+s[i]-x
else:return v[i]+x-s[i]
c=float("INF")
for i in range(n):
c=min(c,f(i,0))
e=0
for i in range(1,2*s[-1]+1):
i=i/2
d=float("INF")
for j in range(n):
d=min(d,f(j,i))
e+=0.25*(c+d)
c=d
print(e)
``` | instruction | 0 | 72,381 | 3 | 144,762 |
No | output | 1 | 72,381 | 3 | 144,763 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
In the year 2168, AtCoder Inc., which is much larger than now, is starting a limited express train service called AtCoder Express.
In the plan developed by the president Takahashi, the trains will run as follows:
* A train will run for (t_1 + t_2 + t_3 + ... + t_N) seconds.
* In the first t_1 seconds, a train must run at a speed of at most v_1 m/s (meters per second). Similarly, in the subsequent t_2 seconds, a train must run at a speed of at most v_2 m/s, and so on.
According to the specifications of the trains, the acceleration of a train must be always within ±1m/s^2. Additionally, a train must stop at the beginning and the end of the run.
Find the maximum possible distance that a train can cover in the run.
Constraints
* 1 \leq N \leq 100
* 1 \leq t_i \leq 200
* 1 \leq v_i \leq 100
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N
t_1 t_2 t_3 … t_N
v_1 v_2 v_3 … v_N
Output
Print the maximum possible that a train can cover in the run.
Output is considered correct if its absolute difference from the judge's output is at most 10^{-3}.
Examples
Input
1
100
30
Output
2100.000000000000000
Input
2
60 50
34 38
Output
2632.000000000000000
Input
3
12 14 2
6 2 7
Output
76.000000000000000
Input
1
9
10
Output
20.250000000000000000
Input
10
64 55 27 35 76 119 7 18 49 100
29 19 31 39 27 48 41 87 55 70
Output
20291.000000000000
Submitted Solution:
```
n = int(input())
tt = list(map(int, input().split()))
v = list(map(int, input().split()))
time = sum(tt);
border = [0] *(n+1)
start_v = [0] *(n+1)
end_v = [0] *(n+1)
temp = 0
for i in range(n):
temp += tt[i]
border[i+1] = temp
start_v[i] = v[i]
end_v[i+1] = v[i]
t = 0
idx = 0
ans = 0
vlast = 0
v0 = 0
# print (border)
while t < time :
t += 0.5
# tle回避
if t < border[idx+1] and abs(v0- (vlast-0.5) ) < 0.001:
v0 = vlast - 0.5
ans += 0.5 * (vlast + v0) / 2
vlast = v0
continue
vlast = v0
#直接制約
v0 = v[idx]
if t == border[idx+1]:
idx += 1
# v0 = min(v0, v[idx])
for j in range(n+1):
if border[j] <= t:
#前の時刻からの制約
temp = end_v[j] + (t - border[j])
if v0 > temp:
v0 = temp
if border[j] >= t:
#後ろの時刻からの制約
temp = start_v[j] + (border[j] - t)
if v0 > temp:
v0 = temp
# print(v0)
# ans += 0.5 * (vlast + v0) / 2
ans += 0.5 * (vlast + v0) / 2
# vlast = v0
print (ans)
``` | instruction | 0 | 72,383 | 3 | 144,766 |
No | output | 1 | 72,383 | 3 | 144,767 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Mobiles are widely known as moving works of art. The IOI Japan Committee has decided to create mobiles to publicize JOI. JOI public relations mobiles are sticks, strings, and weights. It is constructed as follows using the three types of elements of.
* One end of the bar is painted blue and the other end is painted red.
* The rod is hung with a string with one point other than both ends as a fulcrum.
* Both the length from the fulcrum to the red end and the length from the fulcrum to the blue end are positive integers.
* At both ends of the rod, hang a weight or another rod with a string.
* The weight is hung on one end of one of the rods using a string.
* Nothing hangs on the weight.
* The weight of the weight is a positive integer.
* Only one of the strings is tied at one end to the fulcrum of that bar to hang one bar, the other end is not tied to any other component. Meet one or the other.
* Connect the end of a bar to the fulcrum of a bar.
* Connect the end of a rod to a weight.
However, all rods need to be balanced. The weights of the rods and strings are negligibly light, so consider that the weights of the rods and strings are all 0. About the stick,
(Total weight of weights suspended below the red end of the rod) × (Length from the fulcrum of the rod to the red end) = (Hung below the blue end of the rod) Total weight of the weight) × (length from the fulcrum of the rod to the end of the blue)
If, then the bar is balanced.
<image>
The length and how to tie the rods to make up the mobile has already been decided, but the weight of the weight has not been decided yet. The lighter the mobile, the easier it is to hang, so I want to make the mobile as light as possible. As mentioned above, while balancing all the rods, find a way to attach a weight that minimizes the total weight of the mobile, and create a program that outputs the total weight of the mobile at that time. Information about the configuration is given.
* Number of bars n
* Information for each bar (bar numbers 1 to n)
* Ratio of the length from the fulcrum to the red end to the length from the fulcrum to the blue end
* Number of rods to hang on the red end (0 for hanging weights)
* Number of rods to hang on the blue edge (0 for hanging weights)
<image>
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
The first line contains the number of bars n used in the mobile. The following n lines (1 ≤ n ≤ 100) contain the data for each bar. I + 1st line In (1 ≤ i ≤ n), four integers p, q, r, b are written with a blank as a delimiter, and on the bar i, the length from the fulcrum to the red end and the length from the fulcrum to the blue end. The ratio is p: q, the number of the bar hanging at the red end is r, and the number of the bar hanging at the blue end is b, where bar number 0 is the weight. In any input, if the minimum value of the weight of the mobile is w and the maximum value of the positive integer used to express the ratio in the input is L, then wL <231 Meet.
The number of datasets does not exceed 15.
output
The weight of the mobile is output to one line for each data set.
Examples
Input
1
6 9 0 0
4
3 2 0 4
1 3 0 0
4 4 2 1
2 2 0 0
0
Output
5
40
Input
None
Output
None
Submitted Solution:
```
def gcd(a, b):
r = a % b
if r:
return gcd(b, r)
return b
def lcm(a, b):
if a < b:
a, b = b, a
return a * b // gcd(a, b)
def min_weight(m):
p, q, r, b = bars[m - 1]
red = q * (min_weight(r) if r else 1)
blue = p * (min_weight(b) if b else 1)
equilibrium = lcm(red, blue)
return equilibrium // p + equilibrium // q
while True:
n = int(input())
if not n:
break
bars = [tuple(map(int, input().split())) for _ in range(n)]
root_bar = set(range(1, n + 1))
for _, _, r, b in bars:
if r: root_bar.remove(r)
if b: root_bar.remove(b)
print(min_weight(root_bar.pop()))
``` | instruction | 0 | 72,440 | 3 | 144,880 |
No | output | 1 | 72,440 | 3 | 144,881 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Mobiles are widely known as moving works of art. The IOI Japan Committee has decided to create mobiles to publicize JOI. JOI public relations mobiles are sticks, strings, and weights. It is constructed as follows using the three types of elements of.
* One end of the bar is painted blue and the other end is painted red.
* The rod is hung with a string with one point other than both ends as a fulcrum.
* Both the length from the fulcrum to the red end and the length from the fulcrum to the blue end are positive integers.
* At both ends of the rod, hang a weight or another rod with a string.
* The weight is hung on one end of one of the rods using a string.
* Nothing hangs on the weight.
* The weight of the weight is a positive integer.
* Only one of the strings is tied at one end to the fulcrum of that bar to hang one bar, the other end is not tied to any other component. Meet one or the other.
* Connect the end of a bar to the fulcrum of a bar.
* Connect the end of a rod to a weight.
However, all rods need to be balanced. The weights of the rods and strings are negligibly light, so consider that the weights of the rods and strings are all 0. About the stick,
(Total weight of weights suspended below the red end of the rod) × (Length from the fulcrum of the rod to the red end) = (Hung below the blue end of the rod) Total weight of the weight) × (length from the fulcrum of the rod to the end of the blue)
If, then the bar is balanced.
<image>
The length and how to tie the rods to make up the mobile has already been decided, but the weight of the weight has not been decided yet. The lighter the mobile, the easier it is to hang, so I want to make the mobile as light as possible. As mentioned above, while balancing all the rods, find a way to attach a weight that minimizes the total weight of the mobile, and create a program that outputs the total weight of the mobile at that time. Information about the configuration is given.
* Number of bars n
* Information for each bar (bar numbers 1 to n)
* Ratio of the length from the fulcrum to the red end to the length from the fulcrum to the blue end
* Number of rods to hang on the red end (0 for hanging weights)
* Number of rods to hang on the blue edge (0 for hanging weights)
<image>
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
The first line contains the number of bars n used in the mobile. The following n lines (1 ≤ n ≤ 100) contain the data for each bar. I + 1st line In (1 ≤ i ≤ n), four integers p, q, r, b are written with a blank as a delimiter, and on the bar i, the length from the fulcrum to the red end and the length from the fulcrum to the blue end. The ratio is p: q, the number of the bar hanging at the red end is r, and the number of the bar hanging at the blue end is b, where bar number 0 is the weight. In any input, if the minimum value of the weight of the mobile is w and the maximum value of the positive integer used to express the ratio in the input is L, then wL <231 Meet.
The number of datasets does not exceed 15.
output
The weight of the mobile is output to one line for each data set.
Examples
Input
1
6 9 0 0
4
3 2 0 4
1 3 0 0
4 4 2 1
2 2 0 0
0
Output
5
40
Input
None
Output
None
Submitted Solution:
```
from math import gcd
def lcm(i, j):
return i * j // gcd(i, j)
def main():
while True:
n = int(input())
if not n: break
lst = [[]]
weight = [-1 for i in range(n + 1)]
def setWeight(n):
p, q, r, b = lst[n]
if weight[n] != -1: pass
elif r == 0 and b == 0:
weight[n] = (p + q) // gcd(p, q)
elif r == 0:
setWeight(b)
l = lcm(weight[b] * q, p)
weight[n] = l // q + l // p
elif b == 0:
setWeight(r)
l = lcm(weight(r) * p, q)
weight[n] = l // p + l // q
else:
if weight[r] == -1: setWeight(r)
if weight[b] == -1: setWeight(b)
l = lcm(weight[r] * p, weight[b] * q)
weight[n] = l // p + l // q
for i in range(n):
lst.append(list(map(int,input().split())))
for i in range(0, n):
if weight[i + 1] == -1:
setWeight(i + 1)
print(max(weight))
main()
``` | instruction | 0 | 72,441 | 3 | 144,882 |
No | output | 1 | 72,441 | 3 | 144,883 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Mobiles are widely known as moving works of art. The IOI Japan Committee has decided to create mobiles to publicize JOI. JOI public relations mobiles are sticks, strings, and weights. It is constructed as follows using the three types of elements of.
* One end of the bar is painted blue and the other end is painted red.
* The rod is hung with a string with one point other than both ends as a fulcrum.
* Both the length from the fulcrum to the red end and the length from the fulcrum to the blue end are positive integers.
* At both ends of the rod, hang a weight or another rod with a string.
* The weight is hung on one end of one of the rods using a string.
* Nothing hangs on the weight.
* The weight of the weight is a positive integer.
* Only one of the strings is tied at one end to the fulcrum of that bar to hang one bar, the other end is not tied to any other component. Meet one or the other.
* Connect the end of a bar to the fulcrum of a bar.
* Connect the end of a rod to a weight.
However, all rods need to be balanced. The weights of the rods and strings are negligibly light, so consider that the weights of the rods and strings are all 0. About the stick,
(Total weight of weights suspended below the red end of the rod) × (Length from the fulcrum of the rod to the red end) = (Hung below the blue end of the rod) Total weight of the weight) × (length from the fulcrum of the rod to the end of the blue)
If, then the bar is balanced.
<image>
The length and how to tie the rods to make up the mobile has already been decided, but the weight of the weight has not been decided yet. The lighter the mobile, the easier it is to hang, so I want to make the mobile as light as possible. As mentioned above, while balancing all the rods, find a way to attach a weight that minimizes the total weight of the mobile, and create a program that outputs the total weight of the mobile at that time. Information about the configuration is given.
* Number of bars n
* Information for each bar (bar numbers 1 to n)
* Ratio of the length from the fulcrum to the red end to the length from the fulcrum to the blue end
* Number of rods to hang on the red end (0 for hanging weights)
* Number of rods to hang on the blue edge (0 for hanging weights)
<image>
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
The first line contains the number of bars n used in the mobile. The following n lines (1 ≤ n ≤ 100) contain the data for each bar. I + 1st line In (1 ≤ i ≤ n), four integers p, q, r, b are written with a blank as a delimiter, and on the bar i, the length from the fulcrum to the red end and the length from the fulcrum to the blue end. The ratio is p: q, the number of the bar hanging at the red end is r, and the number of the bar hanging at the blue end is b, where bar number 0 is the weight. In any input, if the minimum value of the weight of the mobile is w and the maximum value of the positive integer used to express the ratio in the input is L, then wL <231 Meet.
The number of datasets does not exceed 15.
output
The weight of the mobile is output to one line for each data set.
Examples
Input
1
6 9 0 0
4
3 2 0 4
1 3 0 0
4 4 2 1
2 2 0 0
0
Output
5
40
Input
None
Output
None
Submitted Solution:
```
import math
class Mobile:
def __init__(self,leftratio=0,rightratio=0,left=-1,right=-1):
self.weight = 0
self.leftratio = leftratio
self.rightratio = rightratio
self.left = left
self.leftweight = 0
self.right = right
self.rightweight = 0
def calc(self):
if self.weight != 0 : return self.weight
if self.left == -1:
self.leftweight = 1
else:
self.leftweight = Mobile.calc(self.left)
if self.right == -1:
self.rightweight = 1
else:
self.rightweight = Mobile.calc(self.right)
lmoment = self.leftratio*self.leftweight
rmoment = self.rightratio*self.rightweight
lcs = lmoment * rmoment // math.gcd(lmoment,rmoment)
self.weight = (lcs//self.leftratio) + (lcs//self.rightratio)
return self.weight
def stdout(self):
print(self.left, self.right)
n = int(input())
barlist = [Mobile() for i in range(n)]
for i in range(n):
p,q,r,b = map(int, input().split())
barlist[i].leftratio = p
barlist[i].rightratio = q
if r != 0 : barlist[i].left = barlist[r-1]
if b != 0 : barlist[i].right = barlist[b-1]
maxi = 0
for i in range(n):
maxi = max(barlist[i].calc(),maxi)
print(maxi)
``` | instruction | 0 | 72,442 | 3 | 144,884 |
No | output | 1 | 72,442 | 3 | 144,885 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
problem
Mobiles are widely known as moving works of art. The IOI Japan Committee has decided to create mobiles to publicize JOI. JOI public relations mobiles are sticks, strings, and weights. It is constructed as follows using the three types of elements of.
* One end of the bar is painted blue and the other end is painted red.
* The rod is hung with a string with one point other than both ends as a fulcrum.
* Both the length from the fulcrum to the red end and the length from the fulcrum to the blue end are positive integers.
* At both ends of the rod, hang a weight or another rod with a string.
* The weight is hung on one end of one of the rods using a string.
* Nothing hangs on the weight.
* The weight of the weight is a positive integer.
* Only one of the strings is tied at one end to the fulcrum of that bar to hang one bar, the other end is not tied to any other component. Meet one or the other.
* Connect the end of a bar to the fulcrum of a bar.
* Connect the end of a rod to a weight.
However, all rods need to be balanced. The weights of the rods and strings are negligibly light, so consider that the weights of the rods and strings are all 0. About the stick,
(Total weight of weights suspended below the red end of the rod) × (Length from the fulcrum of the rod to the red end) = (Hung below the blue end of the rod) Total weight of the weight) × (length from the fulcrum of the rod to the end of the blue)
If, then the bar is balanced.
<image>
The length and how to tie the rods to make up the mobile has already been decided, but the weight of the weight has not been decided yet. The lighter the mobile, the easier it is to hang, so I want to make the mobile as light as possible. As mentioned above, while balancing all the rods, find a way to attach a weight that minimizes the total weight of the mobile, and create a program that outputs the total weight of the mobile at that time. Information about the configuration is given.
* Number of bars n
* Information for each bar (bar numbers 1 to n)
* Ratio of the length from the fulcrum to the red end to the length from the fulcrum to the blue end
* Number of rods to hang on the red end (0 for hanging weights)
* Number of rods to hang on the blue edge (0 for hanging weights)
<image>
input
The input consists of multiple datasets. Each dataset is given in the following format. The input ends on a line containing one zero.
The first line contains the number of bars n used in the mobile. The following n lines (1 ≤ n ≤ 100) contain the data for each bar. I + 1st line In (1 ≤ i ≤ n), four integers p, q, r, b are written with a blank as a delimiter, and on the bar i, the length from the fulcrum to the red end and the length from the fulcrum to the blue end. The ratio is p: q, the number of the bar hanging at the red end is r, and the number of the bar hanging at the blue end is b, where bar number 0 is the weight. In any input, if the minimum value of the weight of the mobile is w and the maximum value of the positive integer used to express the ratio in the input is L, then wL <231 Meet.
The number of datasets does not exceed 15.
output
The weight of the mobile is output to one line for each data set.
Examples
Input
1
6 9 0 0
4
3 2 0 4
1 3 0 0
4 4 2 1
2 2 0 0
0
Output
5
40
Input
None
Output
None
Submitted Solution:
```
from math import gcd
while True:
try:
n = int(input())
if not n: break
lst = [[]]
weight = [-1 for i in range(n + 1)]
def setWeight(n):
p,q,r,b = lst[n]
if weight[n] != -1:pass
elif r == 0 and b == 0:
weight[n] = (p + q) // gcd(p,q)
elif r == 0:
setWeight(b)
wb = weight[b]
g = gcd(wb * q, p)
lcm = wb * q * p // g
weight[n] = lcm // q + lcm // p
print("wr:",str(lcm//p),"wb:",str(wb),"g:",g,"p:",p,"lcm",lcm)
elif b == 0:
setWeight(r)
wr = weight[r]
g = gcd(wr * p, q)
lcm = wr * p * q // g
weight[n] = lcm // p + lcm // q
else:
if weight[r] == -1: setWeight(r)
if weight[b] == -1: setWeight(b)
wr = weight[r]
wb = weight[b]
g = gcd(wr * p, wb * q)
lcm = wr * p * wb * q // g
weight[n] = lcm // p + lcm // q
for i in range(n):
lst.append(list(map(int,input().split())))
for i in range(0,n):
if weight[i + 1] == -1:
setWeight(i+1)
print(max(weight))
print(weight)
except EOFError:
break
``` | instruction | 0 | 72,443 | 3 | 144,886 |
No | output | 1 | 72,443 | 3 | 144,887 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Innopolis University scientists continue to investigate the periodic table. There are n·m known elements and they form a periodic table: a rectangle with n rows and m columns. Each element can be described by its coordinates (r, c) (1 ≤ r ≤ n, 1 ≤ c ≤ m) in the table.
Recently scientists discovered that for every four different elements in this table that form a rectangle with sides parallel to the sides of the table, if they have samples of three of the four elements, they can produce a sample of the fourth element using nuclear fusion. So if we have elements in positions (r1, c1), (r1, c2), (r2, c1), where r1 ≠ r2 and c1 ≠ c2, then we can produce element (r2, c2).
<image>
Samples used in fusion are not wasted and can be used again in future fusions. Newly crafted elements also can be used in future fusions.
Innopolis University scientists already have samples of q elements. They want to obtain samples of all n·m elements. To achieve that, they will purchase some samples from other laboratories and then produce all remaining elements using an arbitrary number of nuclear fusions in some order. Help them to find the minimal number of elements they need to purchase.
Input
The first line contains three integers n, m, q (1 ≤ n, m ≤ 200 000; 0 ≤ q ≤ min(n·m, 200 000)), the chemical table dimensions and the number of elements scientists already have.
The following q lines contain two integers ri, ci (1 ≤ ri ≤ n, 1 ≤ ci ≤ m), each describes an element that scientists already have. All elements in the input are different.
Output
Print the minimal number of elements to be purchased.
Examples
Input
2 2 3
1 2
2 2
2 1
Output
0
Input
1 5 3
1 3
1 1
1 5
Output
2
Input
4 3 6
1 2
1 3
2 2
2 3
3 1
3 3
Output
1
Note
For each example you have a picture which illustrates it.
The first picture for each example describes the initial set of element samples available. Black crosses represent elements available in the lab initially.
The second picture describes how remaining samples can be obtained. Red dashed circles denote elements that should be purchased from other labs (the optimal solution should minimize the number of red circles). Blue dashed circles are elements that can be produced with nuclear fusion. They are numbered in order in which they can be produced.
Test 1
We can use nuclear fusion and get the element from three other samples, so we don't need to purchase anything.
<image>
Test 2
We cannot use any nuclear fusion at all as there is only one row, so we have to purchase all missing elements.
<image>
Test 3
There are several possible solutions. One of them is illustrated below.
Note that after purchasing one element marked as red it's still not possible to immidiately produce the middle element in the bottom row (marked as 4). So we produce the element in the left-top corner first (marked as 1), and then use it in future fusions.
<image> | instruction | 0 | 72,479 | 3 | 144,958 |
Tags: constructive algorithms, dfs and similar, dsu, graphs, matrices
Correct Solution:
```
from collections import deque
import os
from io import BytesIO
input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def main():
n,m,q = map(int,input().split())
mn = m + n
cr = [[] for i in range(mn)]
ca = [-1]*(mn)
for i in range(q):
ri,ci = map(int,input().split())
ri -= 1
ci -= 1
cr[ci] += [ri+m]
cr[ri+m] += [ci]
ans = -1
for i in range(mn):
if ca[i] != -1:
continue
ca[i] = 1
stack = deque()
for j in cr[i]:
stack.append(j)
ca[j] = 0
while len(stack) != 0:
temp = stack.pop()
for j in cr[temp]:
if ca[j] == -1:
ca[j] = 0
stack.append(j)
ans += 1
print(ans)
main()
``` | output | 1 | 72,479 | 3 | 144,959 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.