text stringlengths 1.02k 43.5k | conversation_id int64 853 107k | embedding list | cluster int64 24 24 |
|---|---|---|---|
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
n = int(input())
s = set(map(int,input().split()))
cnt = 0
for i in s:
if i <= n:
cnt+=1
print(n-cnt)
```
| 21,365 | [
0.4169921875,
0.1810302734375,
0.0770263671875,
0.05413818359375,
-0.474853515625,
-0.46533203125,
-0.41748046875,
-0.1141357421875,
0.34619140625,
0.64794921875,
1.0849609375,
-0.346923828125,
0.187744140625,
-0.9326171875,
-0.84375,
-0.1572265625,
-0.826171875,
-0.845703125,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
ss=[0]*(n+1)
cnt=0
for i in a:
if i<=n:
if ss[i]:
cnt+=1
else:
ss[i]=1
else:
cnt+=1
print(cnt)
```
| 21,366 | [
0.39501953125,
0.1749267578125,
0.089599609375,
0.07623291015625,
-0.466064453125,
-0.439208984375,
-0.42822265625,
-0.09149169921875,
0.346923828125,
0.6640625,
1.0927734375,
-0.338623046875,
0.179443359375,
-0.9375,
-0.86181640625,
-0.15673828125,
-0.83349609375,
-0.8720703125,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
n=int(input())
l1=[int(i) for i in input().split()]
l2=[]
c=0
for i in l1:
if i not in l2 and i<=n:
l2.append(i)
elif i in l2 and i<=n:
c+=1
elif i>n:
c+=1
print(c)
```
| 21,367 | [
0.440673828125,
0.172607421875,
0.073974609375,
0.062744140625,
-0.5322265625,
-0.468017578125,
-0.424560546875,
-0.07843017578125,
0.350830078125,
0.63037109375,
1.072265625,
-0.345703125,
0.18701171875,
-0.9189453125,
-0.85400390625,
-0.1434326171875,
-0.84326171875,
-0.869628906... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
n=int(input())
s=[int(i) for i in input().split() if int(i)<=n]
t=len(set(s))
print(n-t)
```
| 21,368 | [
0.4248046875,
0.18408203125,
0.08575439453125,
0.059906005859375,
-0.54248046875,
-0.488525390625,
-0.412109375,
-0.1033935546875,
0.37548828125,
0.61181640625,
1.078125,
-0.36474609375,
0.1744384765625,
-0.91552734375,
-0.849609375,
-0.16650390625,
-0.8212890625,
-0.87255859375,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
N = int(input())
A = list(int(i) for i in input().split())
S = set()
for k in A:
if(1<=k and k<=N):
S.add(k)
print(N-len(S))
```
| 21,369 | [
0.433837890625,
0.1864013671875,
0.09771728515625,
0.06317138671875,
-0.55029296875,
-0.48193359375,
-0.432861328125,
-0.104736328125,
0.358154296875,
0.61376953125,
1.07421875,
-0.3740234375,
0.196533203125,
-0.896484375,
-0.84521484375,
-0.12890625,
-0.8349609375,
-0.88232421875,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Tags: greedy
Correct Solution:
```
#from collections import deque,namedtuple
def main():
n = int(input())
s = set([int(i) for i in range(1,n+1)])
for i in input().split():
if int(i) in s:
s.remove(int(i))
print(len(s))
if __name__ == "__main__":
main()
```
| 21,370 | [
0.4013671875,
0.1669921875,
0.07940673828125,
0.052337646484375,
-0.5439453125,
-0.4248046875,
-0.444580078125,
-0.09185791015625,
0.3876953125,
0.5869140625,
1.0634765625,
-0.37939453125,
0.1915283203125,
-0.88037109375,
-0.876953125,
-0.1500244140625,
-0.826171875,
-0.8916015625,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
up = int(input())
nums = input().split()
nums = list(map(int, nums))
nums.sort()
num_count = len(nums)
result = 0
last = None
for i in nums:
if i > up or i == last:
result += 1
else:
last = i
print(result)
```
Yes
| 21,371 | [
0.448974609375,
0.1832275390625,
-0.014556884765625,
0.038421630859375,
-0.66943359375,
-0.3408203125,
-0.54931640625,
0.1031494140625,
0.328369140625,
0.689453125,
1.140625,
-0.25830078125,
0.16064453125,
-0.99755859375,
-0.8447265625,
-0.23046875,
-0.8583984375,
-0.78466796875,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
n=int(input())
a=list(map(int,input().split()))
c=0
for i in range(1,n+1):
if a.count(i)==0:
c=c+1
print(c)
```
Yes
| 21,372 | [
0.435546875,
0.21337890625,
0.031402587890625,
0.048828125,
-0.6923828125,
-0.33447265625,
-0.5498046875,
0.11279296875,
0.280029296875,
0.7060546875,
1.09765625,
-0.23779296875,
0.1563720703125,
-0.98876953125,
-0.83935546875,
-0.2197265625,
-0.88818359375,
-0.74755859375,
-0.67... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
n=int(input())
l=list(map(int,input().split()))
k=0
for i in range(1,n+1):
if(i not in l):
k=k+1
print(k)
```
Yes
| 21,373 | [
0.437744140625,
0.209716796875,
0.013336181640625,
0.05145263671875,
-0.69580078125,
-0.34375,
-0.5498046875,
0.10504150390625,
0.2724609375,
0.6923828125,
1.1015625,
-0.2391357421875,
0.158935546875,
-0.9931640625,
-0.8427734375,
-0.1883544921875,
-0.8935546875,
-0.76513671875,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
n = int(input())
s = set(range(1, n + 1))
val = 0
for a in (int(x) for x in input().split()):
if a in s:
s.remove(a)
else:
val += 1
print(val)
```
Yes
| 21,374 | [
0.416015625,
0.201416015625,
0.045379638671875,
0.08575439453125,
-0.6982421875,
-0.335693359375,
-0.54833984375,
0.100341796875,
0.284423828125,
0.6806640625,
1.0927734375,
-0.255615234375,
0.1328125,
-1.0126953125,
-0.86083984375,
-0.22509765625,
-0.87109375,
-0.76171875,
-0.69... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
n = int(input())
num = list(map(int, input().split(" ")))
aux = map(lambda x: 1 if x > n else 1, num)
print(sum(aux))
```
No
| 21,375 | [
0.4326171875,
0.2181396484375,
0.006103515625,
0.06146240234375,
-0.6796875,
-0.34228515625,
-0.5712890625,
0.1065673828125,
0.279052734375,
0.70947265625,
1.099609375,
-0.232177734375,
0.1446533203125,
-0.982421875,
-0.85888671875,
-0.22900390625,
-0.8759765625,
-0.79638671875,
... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
print(int(input())-len(set(map(int,input().split()))))
```
No
| 21,376 | [
0.448974609375,
0.1895751953125,
0.00009906291961669922,
0.05682373046875,
-0.697265625,
-0.346923828125,
-0.55615234375,
0.0933837890625,
0.2861328125,
0.7119140625,
1.1005859375,
-0.239990234375,
0.1641845703125,
-0.98681640625,
-0.83056640625,
-0.233642578125,
-0.86279296875,
-0... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
n=int(input())
unical=set()
a=list(map(int,input().split(" ")))
for i in a:
unical.add(i)
print(n-len(unical))
```
No
| 21,377 | [
0.439208984375,
0.1741943359375,
0.0013675689697265625,
0.05322265625,
-0.7099609375,
-0.3330078125,
-0.576171875,
0.07330322265625,
0.26171875,
0.71923828125,
1.140625,
-0.266357421875,
0.133056640625,
-0.9931640625,
-0.91455078125,
-0.23193359375,
-0.8720703125,
-0.740234375,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
"Hey, it's homework time" — thought Polycarpus and of course he started with his favourite subject, IT. Polycarpus managed to solve all tasks but for the last one in 20 minutes. However, as he failed to solve the last task after some considerable time, the boy asked you to help him.
The sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
You are given an arbitrary sequence a1, a2, ..., an containing n integers. Each integer is not less than 1 and not greater than 5000. Determine what minimum number of elements Polycarpus needs to change to get a permutation (he should not delete or add numbers). In a single change he can modify any single sequence element (i. e. replace it with another integer).
Input
The first line of the input data contains an integer n (1 ≤ n ≤ 5000) which represents how many numbers are in the sequence. The second line contains a sequence of integers ai (1 ≤ ai ≤ 5000, 1 ≤ i ≤ n).
Output
Print the only number — the minimum number of changes needed to get the permutation.
Examples
Input
3
3 1 2
Output
0
Input
2
2 2
Output
1
Input
5
5 3 3 3 1
Output
2
Note
The first sample contains the permutation, which is why no replacements are required.
In the second sample it is enough to replace the first element with the number 1 and that will make the sequence the needed permutation.
In the third sample we can replace the second element with number 4 and the fourth element with number 2.
Submitted Solution:
```
# Receiving and adjusting inputs
n = int(input())
array = input()
array = list(map(int, array.split(" ")))
answer = 0
# solution
array.sort()
for i in range(1, len(array) + 1):
if i != array[i-1]:
answer = answer + 1
# print answer
print(answer)
```
No
| 21,378 | [
0.44775390625,
0.2266845703125,
-0.01074981689453125,
0.06927490234375,
-0.71728515625,
-0.348388671875,
-0.56689453125,
0.1248779296875,
0.285400390625,
0.697265625,
1.1220703125,
-0.302001953125,
0.1593017578125,
-0.99951171875,
-0.87109375,
-0.265625,
-0.88623046875,
-0.75195312... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
n = int(input())
d = {}
d["polycarp"] = 1
ans = 1
for i in range(n):
s = input()
a = s.split()
a[0] = a[0].lower()
a[2] = a[2].lower()
d[a[0]] = d[a[2]] + 1
ans = max(ans, d[a[0]])
print(ans)
```
| 21,586 | [
0.34423828125,
0.1732177734375,
0.323974609375,
0.07080078125,
-0.2431640625,
-0.412841796875,
-0.55029296875,
-0.1480712890625,
0.2412109375,
0.8984375,
0.9404296875,
-0.196044921875,
0.267333984375,
-0.71923828125,
-0.60546875,
0.0849609375,
-0.81396484375,
-0.67138671875,
-0.6... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
#*special problem----dfs and similar-----dp------graphs------trees-------*1700
class Edge(object):
def __init__(self, src, dest):
self.src=src
self.dest=dest
def getSource(self):
return self.src
def getDestination(self):
return self.dest
def __str__(self):
return str(self.src)+'->'+str(self.dest)
class Graph(object):
def __init__(self):
self.edges=dict()
def addNode(self, node):
if node in self.edges:
return ValueError('Duplicate node')
else:
self.edges[node]=[]
def addEdge(self, edge):
src=edge.getSource()
dest=edge.getDestination()
if src not in self.edges :
return ValueError('Source node absent')
if dest in self.edges[src]: return #duplicate edge
self.edges[src].append(dest)
#self.edges[dest].append(src)
def childrenOf(self, node):
return self.edges[node]
def hasNode(self, node):
return node in self.edges
def __str__(self):
result = ''
for src in self.edges:
for dest in self.edges[src]:
result = result + str(src) + '->' + str(dest) + '\n'
return result[:-1] #omit final newline
n=int(input())
graph= Graph()
rootNode='polycarp'
graph.addNode(rootNode)
for i in range(n):
inp= input().lower().split()
if inp[0] not in graph.edges: graph.addNode(inp[0])
parent = inp[2]
if parent not in graph.edges: graph.addNode(parent)
graph.addEdge(Edge(parent, inp[0]))
def findHeight(graph, rootNode):
if len(graph.edges[rootNode])==0: return 1
else:
maxSubtreeHeight=0
for child in graph.edges[rootNode] :
h=1+findHeight(graph, child)
maxSubtreeHeight=max(maxSubtreeHeight, h)
return maxSubtreeHeight
print(findHeight(graph, rootNode))
```
| 21,587 | [
0.369140625,
0.16015625,
0.357421875,
0.1260986328125,
-0.221435546875,
-0.38525390625,
-0.5556640625,
-0.1116943359375,
0.2119140625,
0.884765625,
0.9384765625,
-0.2047119140625,
0.291259765625,
-0.68310546875,
-0.57861328125,
0.1060791015625,
-0.77001953125,
-0.69775390625,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
# Anuneet Anand
n = int(input())
G = {"polycarp":1}
for i in range(n):
X = list(input().split())
a = X[0].lower()
b = X[2].lower()
if b in G:
G[a]=G[b]+1
else:
G[a]=1
print(max(G.values()))
```
| 21,588 | [
0.3642578125,
0.2000732421875,
0.28369140625,
0.0736083984375,
-0.22998046875,
-0.41845703125,
-0.5244140625,
-0.173095703125,
0.23583984375,
0.91064453125,
0.94287109375,
-0.1875,
0.260986328125,
-0.7568359375,
-0.58984375,
0.08526611328125,
-0.81591796875,
-0.72265625,
-0.63671... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
n = int(input())
pairs = []
idx = dict()
count = 0
for _ in range(n):
a, b, c = map(lambda x: x.lower(), input().split())
if a not in idx:
idx[a] = count
count += 1
if c not in idx:
idx[c] = count
count += 1
pairs.append((a, c))
elems = len(idx)
parent = [i for i in range(elems)]
for tup in pairs:
parent[idx[tup[0]]] = idx[tup[1]]
maxChain = 0
for i in range(elems):
cur = i
chain = 1
while parent[cur] != cur:
cur = parent[cur]
chain += 1
maxChain = max(chain, maxChain)
print(maxChain)
```
| 21,589 | [
0.353759765625,
0.17919921875,
0.325927734375,
0.07061767578125,
-0.251220703125,
-0.4189453125,
-0.56298828125,
-0.1505126953125,
0.252685546875,
0.90625,
0.9423828125,
-0.2005615234375,
0.265625,
-0.71630859375,
-0.611328125,
0.088134765625,
-0.81591796875,
-0.671875,
-0.622070... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
import sys
from collections import defaultdict as dd
def read():
return sys.stdin.readline().strip()
def write(a):
sys.stdout.write(a)
def dfs(d, u, v, cnt):
if v[u] == True:
return cnt
v[u] = True
ans = cnt
for i in d[u]:
ans = max(ans, dfs(d, i, v, cnt + 1))
return ans
def main():
n = int(read())
d = dd(list)
p = set()
for i in range(n):
b, _, a = read().split()
a = a.lower()
b = b.lower()
p.add(a)
p.add(b)
d[a] += [b]
v = {i:False for i in p}
print(dfs(d, 'polycarp', v, 1))
main()
```
| 21,590 | [
0.345703125,
0.178955078125,
0.352294921875,
0.0726318359375,
-0.229736328125,
-0.3837890625,
-0.5654296875,
-0.1802978515625,
0.2493896484375,
0.9130859375,
0.89501953125,
-0.22412109375,
0.287353515625,
-0.68505859375,
-0.5810546875,
0.07781982421875,
-0.81591796875,
-0.650390625... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
n = int(input())
a = {}
a['polycarp'] = 1
for i in range(n):
x = input().split()
a[x[0].lower()] = a[x[2].lower()] + 1
print(max(a.values()))
```
| 21,591 | [
0.34423828125,
0.1685791015625,
0.322021484375,
0.06640625,
-0.244140625,
-0.41162109375,
-0.55224609375,
-0.152099609375,
0.244873046875,
0.89794921875,
0.94140625,
-0.1988525390625,
0.265380859375,
-0.7216796875,
-0.60595703125,
0.0870361328125,
-0.81640625,
-0.66943359375,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
n = int(input())
a = {'polycarp':-1}
for i in range(n):
b = input().lower().split()
a[b[0]] = b[2]
ans = 0
for i in a:
t = 0
s = i
while s!=-1:
t+=1
s = a[s]
if t>ans:
ans = t
print(ans)
```
| 21,592 | [
0.347900390625,
0.1751708984375,
0.3193359375,
0.0718994140625,
-0.24951171875,
-0.41259765625,
-0.55078125,
-0.1573486328125,
0.2459716796875,
0.8935546875,
0.93505859375,
-0.1942138671875,
0.262451171875,
-0.72021484375,
-0.611328125,
0.08221435546875,
-0.81494140625,
-0.66162109... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Tags: *special, dfs and similar, dp, graphs, trees
Correct Solution:
```
from collections import defaultdict, deque
n = int(input())
graph = defaultdict(list)
visited = set()
longest = defaultdict(int)
persons = set()
for _ in range(n):
(x, _, y) = input().strip().split()
graph[y.lower()].append(x.lower())
persons.update([x.lower(), y.lower()])
def dfs(start):
stack = deque([(start, 1)])
res = 1
while len(stack):
node, count = stack.pop()
res = max(res, count)
visited.add(node)
for neb in graph[node]:
if neb in visited:
res = max(res, count + longest[neb])
else:
stack.appendleft((neb, count+1))
longest[start] = res
return res
res = 1
for p in persons:
if p not in visited:
res = max(res, dfs(p))
print(res)
```
| 21,593 | [
0.33837890625,
0.1732177734375,
0.333984375,
0.0655517578125,
-0.2342529296875,
-0.39990234375,
-0.56103515625,
-0.177734375,
0.254150390625,
0.890625,
0.92333984375,
-0.22607421875,
0.26513671875,
-0.70849609375,
-0.59912109375,
0.088134765625,
-0.8203125,
-0.65771484375,
-0.650... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
import itertools
n=int(input())
l={}
for i in range(n):
name1,name2=input().lower().split(" reposted ")
if name2 not in l:
l[name2]=1
l[name1]=l[name2]+1
print(max(l.values()))
```
Yes
| 21,594 | [
0.412109375,
0.225341796875,
0.19482421875,
-0.0498046875,
-0.355712890625,
-0.322021484375,
-0.6962890625,
-0.06793212890625,
0.151123046875,
0.9375,
0.8388671875,
-0.203369140625,
0.236083984375,
-0.7529296875,
-0.5390625,
0.01401519775390625,
-0.7568359375,
-0.69189453125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
a = {"polycarp": 1}
max = 0
for i in range(int(input())):
n, m = input().lower().split(" reposted ")
a[n] = a[m] + 1
if a[m] + 1 > max:
max = a[m] + 1
print(max)
```
Yes
| 21,595 | [
0.42626953125,
0.26171875,
0.21728515625,
-0.0391845703125,
-0.37255859375,
-0.28857421875,
-0.68896484375,
-0.024688720703125,
0.1298828125,
0.93603515625,
0.86962890625,
-0.1827392578125,
0.2154541015625,
-0.74755859375,
-0.568359375,
0.039459228515625,
-0.74853515625,
-0.7036132... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
n = int(input())
str = [input().lower() for i in range(n)]
r = []
all = []
for i in range(n):
tmp = str[i].split(" ")
r.append((tmp[0], tmp[2]))
if not (r[i][1] in all):
all.append(r[i][1])
if not (r[i][0] in all):
all.append(r[i][0])
l = len(all)
g = [list() for i in range(l)]
for i in range(n):
a = all.index(r[i][0])
b = all.index(r[i][1])
g[a].append(b)
g[b].append(a)
used = [0 for i in range(l)]
d = [0 for i in range(l)]
q = [0]
d[0] = 1
used[0] = 1
while len(q) > 0:
v = q.pop(0)
for i in range(len(g[v])):
to = g[v][i]
if used[to] == 0:
q.append(to)
d[to] = d[v] + 1
used[to] = 1
print(max(d))
```
Yes
| 21,596 | [
0.4033203125,
0.268798828125,
0.1998291015625,
-0.02459716796875,
-0.352783203125,
-0.2900390625,
-0.6708984375,
-0.0611572265625,
0.1553955078125,
0.9189453125,
0.89013671875,
-0.2215576171875,
0.21533203125,
-0.78173828125,
-0.58984375,
0.0017375946044921875,
-0.7431640625,
-0.73... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
def r(d,key):
if key in d:
s=0
for i in d[key]:
m=r(d,i)
if m>s: s=m
return s+1
else: return 1
def size(d):
s=0
for i in d:
m=r(d,i)
if m>s: s=m
return s
n=int(input())
a=[input().lower().split() for i in range(n)]
d={}
for i in a:
d[i[2]]=[]
for i in a:
d[i[2]].append(i[0])
s=size(d)
print(s)
```
Yes
| 21,597 | [
0.42236328125,
0.260009765625,
0.201171875,
-0.06219482421875,
-0.351318359375,
-0.290283203125,
-0.70458984375,
-0.0224151611328125,
0.1434326171875,
0.9365234375,
0.8564453125,
-0.1776123046875,
0.22314453125,
-0.74072265625,
-0.53955078125,
0.042022705078125,
-0.76220703125,
-0.... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
def f(a,b,c,d):
if b == c:
d += 1
c = a
return(d)
n = int(input())
#n=5
z = k = 2
s = [None] * n
#a = [None] * n
#b = [None] * n
#u = [None] * n
#s[0] = 'tourist reposted Polycarp'
#s[1] = 'Petr reposted Tourist'
#s[2] = 'WJMZBMR reposted Petr'
#s[3] = 'sdya reposted wjmzbmr'
#s[4] = 'vepifanov reposted sdya'
for i in range(0,n):
s[i] = input()
for i in range(0,n):
s[i] = s[i].lower()
s[i] = s[i].split()
s[i].remove("reposted")
# a.append(s[i][0])
# b.append(s[i][1])
tmp = s[0][0]
#print('s = ', s)
#print()
#print('z = ', z)
i = 1
while i < n:
# print("i = ",i)
# print(s[i][1], " == ",tmp)
if s[i][1] == tmp:
if i+1 < n:
if s[i][0] == s[i+1][1]:
z = f(s[i][0],s[i][1],tmp,z)
tmp = s[i][0]
else:
z = f(s[i][0],s[i][1],tmp,z)
else:
if k < z:
k = z
k = 2
if i+2 < n:
#print("-")
tmp = s[i+2][0]
i = i + 2
#print("!i = ",i)
else:
break;
i+=1
if k < z:
k = z
#for i in range(a.count(None)):
# a.remove(None)
# b.remove(None)
#print(a)
#print()
#print(b)
#print
print(k)
```
No
| 21,598 | [
0.433837890625,
0.26318359375,
0.202392578125,
-0.04833984375,
-0.34912109375,
-0.290771484375,
-0.68115234375,
-0.025054931640625,
0.1395263671875,
0.9423828125,
0.87255859375,
-0.1746826171875,
0.2279052734375,
-0.7470703125,
-0.5380859375,
0.040863037109375,
-0.775390625,
-0.712... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
s = ""
x = eval(input())
s = input()
s = s.lower()
if 1<=x<=200:
for i in range(x-1):
s = s + " reposted " + input()
s = s.lower()
d = s.split(sep=" reposted ")
aList = []
k = 0
for f in range(len(d)):
if d[f] == 'polycarp':
k=2
name1 = d[f-1]
for j in range(len(d)):
if d[j] == name1 and j % 2!=0:
name1=d[j-1]
k = k + 1
aList.append(k)
for o in range(len(d)):
if 2<=(len(d[o]))<=24:
z = 1
else:
z = 0
if z==1:
print(max(aList))
```
No
| 21,599 | [
0.4326171875,
0.25830078125,
0.21630859375,
-0.057586669921875,
-0.384765625,
-0.283203125,
-0.6865234375,
-0.0362548828125,
0.129150390625,
0.94189453125,
0.865234375,
-0.1966552734375,
0.222412109375,
-0.76416015625,
-0.5625,
0.02227783203125,
-0.75537109375,
-0.69775390625,
-0... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
n=int(input());
d1={};
d2={};
maxc=2;
for i in range(n):
[a,b,c]=[i for i in input().split()];
a=a.lower();
c=c.lower();
if(c!="Polycarp"):
d1[a]=c;
d2[c]=a;
d0=list(d1.keys());
for i in d0:
if i in d1:
c=3;
next=d1[i];
del d1[i];
last=i;
while next in d1:
next0=next;
next=d1[next];
c=c+1;
del d1[next0];
while last in d2:
last=d2[last];
c=c+1;
if(c>maxc):
maxc=c;
print(maxc);
```
No
| 21,600 | [
0.415283203125,
0.250732421875,
0.203369140625,
-0.0576171875,
-0.36767578125,
-0.29931640625,
-0.68408203125,
-0.037841796875,
0.1337890625,
0.94140625,
0.8642578125,
-0.1973876953125,
0.2203369140625,
-0.76123046875,
-0.5654296875,
0.0142974853515625,
-0.7607421875,
-0.7041015625... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp published a funny picture in a social network making a poll about the color of his handle. Many of his friends started reposting Polycarp's joke to their news feed. Some of them reposted the reposts and so on.
These events are given as a sequence of strings "name1 reposted name2", where name1 is the name of the person who reposted the joke, and name2 is the name of the person from whose news feed the joke was reposted. It is guaranteed that for each string "name1 reposted name2" user "name1" didn't have the joke in his feed yet, and "name2" already had it in his feed by the moment of repost. Polycarp was registered as "Polycarp" and initially the joke was only in his feed.
Polycarp measures the popularity of the joke as the length of the largest repost chain. Print the popularity of Polycarp's joke.
Input
The first line of the input contains integer n (1 ≤ n ≤ 200) — the number of reposts. Next follow the reposts in the order they were made. Each of them is written on a single line and looks as "name1 reposted name2". All the names in the input consist of lowercase or uppercase English letters and/or digits and have lengths from 2 to 24 characters, inclusive.
We know that the user names are case-insensitive, that is, two names that only differ in the letter case correspond to the same social network user.
Output
Print a single integer — the maximum length of a repost chain.
Examples
Input
5
tourist reposted Polycarp
Petr reposted Tourist
WJMZBMR reposted Petr
sdya reposted wjmzbmr
vepifanov reposted sdya
Output
6
Input
6
Mike reposted Polycarp
Max reposted Polycarp
EveryOne reposted Polycarp
111 reposted Polycarp
VkCup reposted Polycarp
Codeforces reposted Polycarp
Output
2
Input
1
SoMeStRaNgEgUe reposted PoLyCaRp
Output
2
Submitted Solution:
```
n = int(input())
data = []
for i in range(n):
data.append(input().lower())
start_person = data[0].split(' ')[2]
initials = []
for i in range(len(data)):
if start_person in data[i]:
initials.append(i)
global_length = 0
for i in range(len(initials)):
tmp = data[initials[i]].split(' ')[0]
length = 1
for j in range (initials[i], len(data)):
if tmp in data[j]:
tmp = data[j].split(' ')[0]
length += 1
if global_length < length:
global_length = length
print(global_length)
```
No
| 21,601 | [
0.40966796875,
0.248779296875,
0.2125244140625,
-0.05419921875,
-0.3662109375,
-0.29638671875,
-0.6796875,
-0.03875732421875,
0.1455078125,
0.93701171875,
0.86083984375,
-0.1986083984375,
0.2091064453125,
-0.75927734375,
-0.55517578125,
0.0011491775512695312,
-0.7587890625,
-0.7006... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#'%.9f'%ans
#sys.stdout.flush()
##########################################################
from collections import Counter
import math
from string import ascii_lowercase as al
#for _ in range(int(input())):
#n=int(input())
#n, k = map(int, input().split())
#arr=list(map(int,input().split()))
#for i in range(n):
import bisect
def add(i,val):
while i<=n:
bit[i].append(val)
i+=(i&-i)
def query(i,x):
s=0
while i>0:
pos=bisect.bisect_left(bit[i],x)
s+=len(bit[i])-pos
i-=(i&-i)
return s
n=int(input())
bit=[[] for i in range(n+3)]
a = [int(i) for i in input().split()]
a.insert(0, 0)
for i in range(1,n+1):
add(i,a[i])
for i in range(1,n+1):
bit[i].sort()
ans=0
for i in range(1,n+1):
if a[i]<=i:
continue
ans+=query(min(a[i],n),i)-query(i,i)
print(ans)
```
| 22,583 | [
0.6279296875,
0.384033203125,
-0.061004638671875,
0.170654296875,
-0.315673828125,
-0.72314453125,
-0.69140625,
0.358154296875,
0.390869140625,
0.86865234375,
0.8486328125,
-0.09600830078125,
0.4912109375,
-0.5947265625,
-0.47900390625,
-0.08331298828125,
-0.55810546875,
-0.5297851... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
from sys import stdin
from sys import setrecursionlimit as SRL; SRL(10**7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
n = int(rd())
a = list(rrd())
bit = [0] * (n+10)
def get(x):
tot = 0
while x:
tot += bit[x]
x -= x&(-x)
return tot
def ins(x):
while x<=(n+1):
bit[x] += 1
x += x&(-x)
b = []
preans = 0
for i,v in enumerate(a):
if v > i:
preans += 1
b.append([i+1,v])
b.sort(key=lambda x:x[1])
ans = 0
i = 0
for x in b:
while i<n and i < x[1]:
ins(a[i])
i += 1
ans += i - get(x[0] - 1)
print((ans-preans)//2)
```
| 22,584 | [
0.62451171875,
0.46337890625,
-0.033172607421875,
0.1483154296875,
-0.2939453125,
-0.69140625,
-0.7158203125,
0.351806640625,
0.332763671875,
0.869140625,
0.875,
-0.12646484375,
0.461181640625,
-0.56298828125,
-0.492919921875,
-0.11993408203125,
-0.5673828125,
-0.45361328125,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
import types
_atcoder_code = """
# Python port of AtCoder Library.
__all__ = ["string","lazysegtree","convolution","maxflow","modint"
,"mincostflow","segtree","_scc","_math","math","dsu","twosat","fenwicktree","scc","_bit","lca","unverified","graph","matrix","algebra","combinatorics"]
__version__ = '0.0.1'
"""
atcoder = types.ModuleType('atcoder')
exec(_atcoder_code, atcoder.__dict__)
_atcoder__bit_code = """
def _ceil_pow2(n: int) -> int:
x = 0
while (1 << x) < n:
x += 1
return x
def _bsf(n: int) -> int:
x = 0
while n % 2 == 0:
x += 1
n //= 2
return x
"""
atcoder._bit = types.ModuleType('atcoder._bit')
exec(_atcoder__bit_code, atcoder._bit.__dict__)
_atcoder_segtree_code = """
import typing
# import atcoder._bit
class SegTree:
'''
Segment Tree Library.
op(S,S) -> S
e = Identity element
SegTree(op,e,n) := Initialized by [e]*(n)
SegTree(op,e,vector) := Initialized by vector
'''
def __init__(self,
op: typing.Callable[[typing.Any, typing.Any], typing.Any],
e: typing.Any,
v: typing.Union[int, typing.List[typing.Any]]) -> None:
self._op = op
self._e = e
if isinstance(v, int):
v = [e] * v
self._n = len(v)
self._log = atcoder._bit._ceil_pow2(self._n)
self._size = 1 << self._log
self._d = [e] * (2 * self._size)
for i in range(self._n):
self._d[self._size + i] = v[i]
for i in range(self._size - 1, 0, -1):
self._update(i)
def set(self, p: int, x: typing.Any) -> None:
'''
a[p] -> x in O(logN).
'''
assert 0 <= p < self._n
p += self._size
self._d[p] = x
for i in range(1, self._log + 1):
self._update(p >> i)
def increment(self, p: int, x : typing.Any) -> None:
'''
a[p] -> a[p] + x in O(logN).
'''
assert 0 <= p < self._n
p += self._size
self._d[p] += x
for i in range(1,self._log + 1):
self._update(p >> i)
def get(self, p: int) -> typing.Any:
'''
return a[p] in O(1).
'''
assert 0 <= p < self._n
return self._d[p + self._size]
def prod(self, left: int, right: int) -> typing.Any:
'''
return op(a[l...r)) in O(logN).
'''
assert 0 <= left <= right <= self._n
sml = self._e
smr = self._e
left += self._size
right += self._size
while left < right:
if left & 1:
sml = self._op(sml, self._d[left])
left += 1
if right & 1:
right -= 1
smr = self._op(self._d[right], smr)
left >>= 1
right >>= 1
return self._op(sml, smr)
def all_prod(self) -> typing.Any:
return self._d[1]
def max_right(self, left: int,
f: typing.Callable[[typing.Any], bool]) -> int:
'''
let f(S) -> bool and l is const.
return maximum r for which f(op[l...r)) == true is satisfied, in O(logN).
'''
assert 0 <= left <= self._n
# assert f(self._e)
if left == self._n:
return self._n
left += self._size
sm = self._e
first = True
while first or (left & -left) != left:
first = False
while left % 2 == 0:
left >>= 1
if not f(self._op(sm, self._d[left])):
while left < self._size:
left *= 2
if f(self._op(sm, self._d[left])):
sm = self._op(sm, self._d[left])
left += 1
return left - self._size
sm = self._op(sm, self._d[left])
left += 1
return self._n
def min_left(self, right: int,
f: typing.Callable[[typing.Any], bool]) -> int:
'''
let f(S) -> bool and r is const.
return minimum l for which f(op[l...r)) == true is satisfied, in O(logN).
'''
assert 0 <= right <= self._n
# assert f(self._e)
if right == 0:
return 0
right += self._size
sm = self._e
first = True
while first or (right & -right) != right:
first = False
right -= 1
while right > 1 and right % 2:
right >>= 1
if not f(self._op(self._d[right], sm)):
while right < self._size:
right = 2 * right + 1
if f(self._op(self._d[right], sm)):
sm = self._op(self._d[right], sm)
right -= 1
return right + 1 - self._size
sm = self._op(self._d[right], sm)
return 0
def _update(self, k: int) -> None:
self._d[k] = self._op(self._d[2 * k], self._d[2 * k + 1])
"""
atcoder.segtree = types.ModuleType('atcoder.segtree')
atcoder.segtree.__dict__['atcoder'] = atcoder
atcoder.segtree.__dict__['atcoder._bit'] = atcoder._bit
exec(_atcoder_segtree_code, atcoder.segtree.__dict__)
SegTree = atcoder.segtree.SegTree
# from atcoder.segtree import SegTree
import sys
#Library Info(ACL for Python/Pypy) -> https://github.com/not522/ac-library-python
def input():
return sys.stdin.readline().rstrip()
from collections import deque
def main():
n = int(input())
a = list(map(int, input().split()))
#iのちいさいほうからみる
Q = SegTree(lambda x, y: x + y, 0, [1]*(n))
b = [(a[i], i) for i in range(n)]
b.sort(key=lambda x: x[0])
b = deque(b)
ans = 0
for i in range(n):
while b and b[0][0] < i + 1:
val,idx = b.popleft()
Q.set(idx,0)
if min(a[i],n) > 0:
ans += Q.prod(0,min(a[i],n))
for i in range(n):
if a[i] >= i + 1:
ans -= 1
assert ans % 2 == 0
ans //= 2
print(ans)
return 0
if __name__ == "__main__":
main()
```
| 22,585 | [
0.6142578125,
0.37451171875,
-0.072509765625,
0.2012939453125,
-0.302734375,
-0.7763671875,
-0.70458984375,
0.360595703125,
0.36669921875,
0.8037109375,
0.833984375,
-0.1861572265625,
0.5107421875,
-0.6533203125,
-0.4833984375,
-0.217529296875,
-0.603515625,
-0.55029296875,
-0.40... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
from bisect import bisect_left, bisect_right
n = int(input())
a = list(map(int, input().split()))
ans = 0
#ans = slow_test()
class fenwick():
"""
This Tree Data Structure speeds up caliculating summations of partial sum
and also updating subsets of sequences. Both queries finish in logarithmic times.
"""
# 1-indexed
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def to_sum(self, i):
# return sigma(a_j) (0<=j<=i)
s = 0
while i > 0:
s += self.data[i]
i -= (i & -i)
return s
def add(self, i, x):
#a_i -> a_i + x
while i <= self.n:
self.data[i] += x
i += (i & -i)
def get(self, i, j):
# return sigma(a_k) (i<=k<=j)
# assert 1<=i<=j<= N
return self.to_sum(j)-self.to_sum(i-1)
Q = fenwick(n + 10)
BIGGER = n + 5
seq = [(a[i], i) for i in range(n)]
A = a.copy()
for i in range(n):
if i < a[i]:
ans -= 1
a.sort()
seq.sort(key=lambda x: x[0])
lindex = 0
for a_r, r in seq:
if a_r > n:
ans += n - bisect_right(a, r)
continue
else:
for i in range(lindex, a_r):
if A[i] <= n:
Q.add(A[i], 1)
else:
Q.add(BIGGER, 1)
ans += Q.get(r+1, BIGGER + 1)
lindex = a_r
ans //= 2
print(ans)
```
| 22,586 | [
0.5859375,
0.4296875,
-0.06988525390625,
0.139892578125,
-0.325439453125,
-0.72412109375,
-0.6640625,
0.32373046875,
0.31396484375,
0.95458984375,
0.853515625,
-0.059173583984375,
0.544921875,
-0.67431640625,
-0.51953125,
-0.140625,
-0.57861328125,
-0.58251953125,
-0.369140625,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
from sys import stdin
from sys import setrecursionlimit as SRL; SRL(10**7)
rd = stdin.readline
rrd = lambda: map(int, rd().strip().split())
n = int(input())
a = list(rrd())
bit = [0]*(n+100)
def ins(x):
while x<=n:
bit[x] += 1
x += x&(-x)
def get(l):
tot = 0
while l:
tot += bit[l]
l -= l&(-l)
return tot
ta = []
pans = 0
for i in range(len(a)):
if a[i] > i:
pans += 1
ta.append([i+1, a[i]])
ta.sort(key=lambda x: x[1])
ans = 0
now = 0
for x in ta:
while now < min(n,x[1]):
if a[now] <= n:
ins(a[now])
now += 1
ans += now - get(x[0]-1)
print((ans-pans)//2)
```
| 22,587 | [
0.62451171875,
0.46337890625,
-0.033172607421875,
0.1483154296875,
-0.2939453125,
-0.69140625,
-0.7158203125,
0.351806640625,
0.332763671875,
0.869140625,
0.875,
-0.12646484375,
0.461181640625,
-0.56298828125,
-0.492919921875,
-0.11993408203125,
-0.5673828125,
-0.45361328125,
-0.... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
def divisors(M):
d=[]
i=1
while M>=i**2:
if M%i==0:
d.append(i)
if i**2!=M:
d.append(M//i)
i=i+1
return d
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
def eratosthenes(n):
res=[0 for i in range(n+1)]
prime=set([])
for i in range(2,n+1):
if not res[i]:
prime.add(i)
for j in range(1,n//i+1):
res[i*j]=1
return prime
def factorization(n):
res=[]
for p in prime:
if n%p==0:
while n%p==0:
n//=p
res.append(p)
if n!=1:
res.append(n)
return res
def euler_phi(n):
res = n
for x in range(2,n+1):
if x ** 2 > n:
break
if n%x==0:
res = res//x * (x-1)
while n%x==0:
n //= x
if n!=1:
res = res//n * (n-1)
return res
def ind(b,n):
res=0
while n%b==0:
res+=1
n//=b
return res
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2, 3, 5, 7, 11, 13, 17]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
from math import gcd
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def divisors(n):
res = [1]
prime = primeFactor(n)
for p in prime:
newres = []
for d in res:
for j in range(prime[p]+1):
newres.append(d*p**j)
res = newres
res.sort()
return res
def xorfactorial(num):#排他的論理和の階乗
if num==0:
return 0
elif num==1:
return 1
elif num==2:
return 3
elif num==3:
return 0
else:
x=baseorder(num)
return (2**x)*((num-2**x+1)%2)+function(num-2**x)
def xorconv(n,X,Y):
if n==0:
res=[(X[0]*Y[0])%mod]
return res
x=[X[i]+X[i+2**(n-1)] for i in range(2**(n-1))]
y=[Y[i]+Y[i+2**(n-1)] for i in range(2**(n-1))]
z=[X[i]-X[i+2**(n-1)] for i in range(2**(n-1))]
w=[Y[i]-Y[i+2**(n-1)] for i in range(2**(n-1))]
res1=xorconv(n-1,x,y)
res2=xorconv(n-1,z,w)
former=[(res1[i]+res2[i])*inv for i in range(2**(n-1))]
latter=[(res1[i]-res2[i])*inv for i in range(2**(n-1))]
former=list(map(lambda x:x%mod,former))
latter=list(map(lambda x:x%mod,latter))
return former+latter
def merge_sort(A,B):
pos_A,pos_B = 0,0
n,m = len(A),len(B)
res = []
while pos_A < n and pos_B < m:
a,b = A[pos_A],B[pos_B]
if a < b:
res.append(a)
pos_A += 1
else:
res.append(b)
pos_B += 1
res += A[pos_A:]
res += B[pos_B:]
return res
class UnionFindVerSize():
def __init__(self, N):
self._parent = [n for n in range(0, N)]
self._size = [1] * N
self.group = N
def find_root(self, x):
if self._parent[x] == x: return x
self._parent[x] = self.find_root(self._parent[x])
stack = [x]
while self._parent[stack[-1]]!=stack[-1]:
stack.append(self._parent[stack[-1]])
for v in stack:
self._parent[v] = stack[-1]
return self._parent[x]
def unite(self, x, y):
gx = self.find_root(x)
gy = self.find_root(y)
if gx == gy: return
self.group -= 1
if self._size[gx] < self._size[gy]:
self._parent[gx] = gy
self._size[gy] += self._size[gx]
else:
self._parent[gy] = gx
self._size[gx] += self._size[gy]
def get_size(self, x):
return self._size[self.find_root(x)]
def is_same_group(self, x, y):
return self.find_root(x) == self.find_root(y)
class WeightedUnionFind():
def __init__(self,N):
self.parent = [i for i in range(N)]
self.size = [1 for i in range(N)]
self.val = [0 for i in range(N)]
self.flag = True
self.edge = [[] for i in range(N)]
def dfs(self,v,pv):
stack = [(v,pv)]
new_parent = self.parent[pv]
while stack:
v,pv = stack.pop()
self.parent[v] = new_parent
for nv,w in self.edge[v]:
if nv!=pv:
self.val[nv] = self.val[v] + w
stack.append((nv,v))
def unite(self,x,y,w):
if not self.flag:
return
if self.parent[x]==self.parent[y]:
self.flag = (self.val[x] - self.val[y] == w)
return
if self.size[self.parent[x]]>self.size[self.parent[y]]:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[x] += self.size[y]
self.val[y] = self.val[x] - w
self.dfs(y,x)
else:
self.edge[x].append((y,-w))
self.edge[y].append((x,w))
self.size[y] += self.size[x]
self.val[x] = self.val[y] + w
self.dfs(x,y)
class Dijkstra():
class Edge():
def __init__(self, _to, _cost):
self.to = _to
self.cost = _cost
def __init__(self, V):
self.G = [[] for i in range(V)]
self._E = 0
self._V = V
@property
def E(self):
return self._E
@property
def V(self):
return self._V
def add_edge(self, _from, _to, _cost):
self.G[_from].append(self.Edge(_to, _cost))
self._E += 1
def shortest_path(self, s):
import heapq
que = []
d = [10**15] * self.V
d[s] = 0
heapq.heappush(que, (0, s))
while len(que) != 0:
cost, v = heapq.heappop(que)
if d[v] < cost: continue
for i in range(len(self.G[v])):
e = self.G[v][i]
if d[e.to] > d[v] + e.cost:
d[e.to] = d[v] + e.cost
heapq.heappush(que, (d[e.to], e.to))
return d
#Z[i]:length of the longest list starting from S[i] which is also a prefix of S
#O(|S|)
def Z_algorithm(s):
N = len(s)
Z_alg = [0]*N
Z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]:
j += 1
Z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k + Z_alg[k]<j:
Z_alg[i+k] = Z_alg[k]
k += 1
i += k
j -= k
return Z_alg
class BIT():
def __init__(self,n):
self.BIT=[0]*(n+1)
self.num=n
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.num:
self.BIT[idx] += x
idx += idx&(-idx)
return
class dancinglink():
def __init__(self,n,debug=False):
self.n = n
self.debug = debug
self._left = [i-1 for i in range(n)]
self._right = [i+1 for i in range(n)]
self.exist = [True for i in range(n)]
def pop(self,k):
if self.debug:
assert self.exist[k]
L = self._left[k]
R = self._right[k]
if L!=-1:
if R!=self.n:
self._right[L],self._left[R] = R,L
else:
self._right[L] = self.n
elif R!=self.n:
self._left[R] = -1
self.exist[k] = False
def left(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._left[res]
if res==-1:
break
k -= 1
return res
def right(self,idx,k=1):
if self.debug:
assert self.exist[idx]
res = idx
while k:
res = self._right[res]
if res==self.n:
break
k -= 1
return res
class SparseTable():
def __init__(self,A,merge_func,ide_ele):
N=len(A)
n=N.bit_length()
self.table=[[ide_ele for i in range(n)] for i in range(N)]
self.merge_func=merge_func
for i in range(N):
self.table[i][0]=A[i]
for j in range(1,n):
for i in range(0,N-2**j+1):
f=self.table[i][j-1]
s=self.table[i+2**(j-1)][j-1]
self.table[i][j]=self.merge_func(f,s)
def query(self,s,t):
b=t-s+1
m=b.bit_length()-1
return self.merge_func(self.table[s][m],self.table[t-2**m+1][m])
class BinaryTrie:
class node:
def __init__(self,val):
self.left = None
self.right = None
self.max = val
def __init__(self):
self.root = self.node(-10**15)
def append(self,key,val):
pos = self.root
for i in range(29,-1,-1):
pos.max = max(pos.max,val)
if key>>i & 1:
if pos.right is None:
pos.right = self.node(val)
pos = pos.right
else:
pos = pos.right
else:
if pos.left is None:
pos.left = self.node(val)
pos = pos.left
else:
pos = pos.left
pos.max = max(pos.max,val)
def search(self,M,xor):
res = -10**15
pos = self.root
for i in range(29,-1,-1):
if pos is None:
break
if M>>i & 1:
if xor>>i & 1:
if pos.right:
res = max(res,pos.right.max)
pos = pos.left
else:
if pos.left:
res = max(res,pos.left.max)
pos = pos.right
else:
if xor>>i & 1:
pos = pos.right
else:
pos = pos.left
if pos:
res = max(res,pos.max)
return res
def solveequation(edge,ans,n,m):
#edge=[[to,dire,id]...]
x=[0]*m
used=[False]*n
for v in range(n):
if used[v]:
continue
y = dfs(v)
if y!=0:
return False
return x
def dfs(v):
used[v]=True
r=ans[v]
for to,dire,id in edge[v]:
if used[to]:
continue
y=dfs(to)
if dire==-1:
x[id]=y
else:
x[id]=-y
r+=y
return r
class Matrix():
mod=10**9+7
def set_mod(m):
Matrix.mod=m
def __init__(self,L):
self.row=len(L)
self.column=len(L[0])
self._matrix=L
for i in range(self.row):
for j in range(self.column):
self._matrix[i][j]%=Matrix.mod
def __getitem__(self,item):
if type(item)==int:
raise IndexError("you must specific row and column")
elif len(item)!=2:
raise IndexError("you must specific row and column")
i,j=item
return self._matrix[i][j]
def __setitem__(self,item,val):
if type(item)==int:
raise IndexError("you must specific row and column")
elif len(item)!=2:
raise IndexError("you must specific row and column")
i,j=item
self._matrix[i][j]=val
def __add__(self,other):
if (self.row,self.column)!=(other.row,other.column):
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(self.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(self.column):
res[i][j]=self._matrix[i][j]+other._matrix[i][j]
res[i][j]%=Matrix.mod
return Matrix(res)
def __sub__(self,other):
if (self.row,self.column)!=(other.row,other.column):
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(self.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(self.column):
res[i][j]=self._matrix[i][j]-other._matrix[i][j]
res[i][j]%=Matrix.mod
return Matrix(res)
def __mul__(self,other):
if type(other)!=int:
if self.column!=other.row:
raise SizeError("sizes of matrixes are different")
res=[[0 for j in range(other.column)] for i in range(self.row)]
for i in range(self.row):
for j in range(other.column):
temp=0
for k in range(self.column):
temp+=self._matrix[i][k]*other._matrix[k][j]
res[i][j]=temp%Matrix.mod
return Matrix(res)
else:
n=other
res=[[(n*self._matrix[i][j])%Matrix.mod for j in range(self.column)] for i in range(self.row)]
return Matrix(res)
def __pow__(self,m):
if self.column!=self.row:
raise MatrixPowError("the size of row must be the same as that of column")
n=self.row
res=Matrix([[int(i==j) for i in range(n)] for j in range(n)])
while m:
if m%2==1:
res=res*self
self=self*self
m//=2
return res
def __str__(self):
res=[]
for i in range(self.row):
for j in range(self.column):
res.append(str(self._matrix[i][j]))
res.append(" ")
res.append("\n")
res=res[:len(res)-1]
return "".join(res)
class SegmentTree:
def __init__(self, init_val, segfunc, ide_ele):
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
for i in range(n):
self.tree[self.num + i] = init_val[i]
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
def bisect_l(self,l,r,x):
l += self.num
r += self.num
Lmin = -1
Rmin = -1
while l<r:
if l & 1:
if self.tree[l] <= x and Lmin==-1:
Lmin = l
l += 1
if r & 1:
if self.tree[r-1] <=x:
Rmin = r-1
l >>= 1
r >>= 1
if Lmin != -1:
pos = Lmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
elif Rmin != -1:
pos = Rmin
while pos<self.num:
if self.tree[2 * pos] <=x:
pos = 2 * pos
else:
pos = 2 * pos +1
return pos-self.num
else:
return -1
import sys,random,bisect
from collections import deque,defaultdict
from heapq import heapify,heappop,heappush
from itertools import permutations
from math import log,gcd
input = lambda :sys.stdin.readline().rstrip()
mi = lambda :map(int,input().split())
li = lambda :list(mi())
N = int(input())
A = li()
Seg = SegmentTree([0]*N,lambda x,y:x+y,0)
query = []
for i in range(N):
query.append((i+1,-1))
query.append((A[i],i))
query.sort()
res = 0
for val,t in query[::-1]:
if t==-1:
idx = val - 1
a = A[idx]
res += Seg.query(idx+1,min(a,N))
else:
idx = t
Seg.update(t,1)
print(res)
```
| 22,588 | [
0.60595703125,
0.37890625,
-0.06805419921875,
0.109130859375,
-0.248291015625,
-0.744140625,
-0.67578125,
0.367919921875,
0.352294921875,
0.88671875,
0.8408203125,
-0.0989990234375,
0.51904296875,
-0.60107421875,
-0.46875,
-0.103271484375,
-0.58251953125,
-0.5361328125,
-0.295654... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
import bisect
def lowbit(x):
return(x&-x)
def add(i,x):
while i<=n:
bit[i].append(x)
i+=lowbit(i)
def query(i,x):
s=0
#print(i)
while i>0:
pos = bisect.bisect_left(bit[i],x)
s+=len(bit[i])-pos
i-=lowbit(i)
return(s)
n=int(input())
bit=[[] for i in range(n+2)]
a=[int(i) for i in input().split()]
a.insert(0,0)
for i in range(1,n+1):
add(i,a[i])
ans=0
for i in range(1,n+1):
bit[i].sort()
for i in range(1,n+1):
if a[i]<=i:
continue
ans+=query(min(n,a[i]),i)-query(i,i)
print(ans)
```
| 22,589 | [
0.62158203125,
0.39599609375,
-0.07012939453125,
0.1480712890625,
-0.302490234375,
-0.767578125,
-0.685546875,
0.3203125,
0.32666015625,
0.89111328125,
0.84130859375,
-0.0992431640625,
0.483642578125,
-0.66259765625,
-0.49609375,
-0.10650634765625,
-0.55859375,
-0.55517578125,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Tags: data structures
Correct Solution:
```
import sys
from collections import defaultdict
class BIT_RSQ(object):
__slots__ = ['nodes', 'size']
def __init__(self, size: int):
self.nodes = [0]*(size+1)
self.size = size+1
def add(self, index: int, value: int):
while index < self.size:
self.nodes[index] += value
index += index & -index
def sum(self, right: int):
result = 0
while right:
result += self.nodes[right]
right -= right & -right
return result
n = int(input())
a = list(map(int, input().split()))
bit = BIT_RSQ(n+10)
remove = defaultdict(list)
ans = 0
for i, x in enumerate(a, start=1):
ans += bit.sum(min(i, x))
if i < x:
bit.add(i, 1)
remove[min(n+1, x)].append(i)
for j in remove[i]:
bit.add(j, -1)
print(ans)
```
| 22,590 | [
0.6328125,
0.363525390625,
-0.044281005859375,
0.1417236328125,
-0.281494140625,
-0.69921875,
-0.70263671875,
0.326171875,
0.3310546875,
0.85009765625,
0.859375,
-0.16552734375,
0.45166015625,
-0.5859375,
-0.44189453125,
-0.0855712890625,
-0.51806640625,
-0.47119140625,
-0.338623... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Submitted Solution:
```
import sys
class RangeBit:
def __init__(self, n):
sz = 1
while n >= sz:
sz *= 2
self.size = sz
self.dataAdd = [0 for _ in range(sz)]
self.dataMul = [0 for _ in range(sz)]
def sum(self, i):
assert i > 0
add, mul, start = 0, 0, i
while i > 0:
add += self.dataAdd[i]
mul += self.dataMul[i]
i -= i & -i
return mul * start + add
def add(self, left, right, by):
assert 0 < left <= right
self._add(left, by, -by * (left - 1))
self._add(right, -by, by * right)
def _add(self, i, mul, add):
assert i > 0
while i < self.size:
self.dataAdd[i] += add
self.dataMul[i] += mul
i += i & -i
n = int(input())
l = list(map(int, sys.stdin.readline().split()))
queries = []
for i in range(n):
if min(l[i], n) >= i+2:
queries.append((i+2, min(l[i], n), i+1))
result = 0
a = sorted(list(zip(range(1, n+1), l)) + queries, key=lambda x:(-x[-1], len(x)))
ft = RangeBit(n+1)
for el in a:
#print(el)
if len(el) == 2: #update
ind, val = el
ft.add(ind, ind, 1)
else: #query
fr, to, val = el
# print(fr, to, val)
# print(ft.sum(to) - (ft.sum(fr - 1) if fr > 1 else 0))
result += ft.sum(to) - (ft.sum(fr - 1) if fr > 1 else 0)
print(result)
```
Yes
| 22,591 | [
0.736328125,
0.417724609375,
-0.107177734375,
0.1309814453125,
-0.41015625,
-0.6162109375,
-0.7470703125,
0.416748046875,
0.2330322265625,
0.8828125,
0.85205078125,
-0.085693359375,
0.5087890625,
-0.6748046875,
-0.5146484375,
-0.170654296875,
-0.441650390625,
-0.5078125,
-0.31396... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Submitted Solution:
```
n=int(input().split()[0])
ns=[None]
ns+=[int(s) for s in input().split()[:n]]
d={}
for i in range(1,n+1):
if ns[i] not in d:
d[ns[i]]=[i]
else:
d[ns[i]].append(i)
max_int=999999
tree=[None]*(8*n)
def build(l,r,rt):
global tree
if l==r:
if ns[l]>=n:
tree[rt]=1
else:
tree[rt]=0
return tree[rt]
m=(l+r)//2
left=build(l,m,rt*2)
right=build(m+1,r,rt*2+1)
sum=left+right
tree[rt]=sum
return sum
def query(l,r,bl=1,br=n,rt=1):
if r<l:
return 0
if r<bl or l>br:
return 0
if bl>=l and br<=r:
return tree[rt]
m=(br+bl)//2
left=query(l,r,bl,m,rt*2)
right = query(l, r, m + 1, br, rt * 2 + 1)
sum=left+right
return sum
def change(i,bl=1,br=n,rt=1):
if i<bl or i>br:
return
if bl==br:
tree[rt]-=1
return
tree[rt]-=1
m=(br+bl)//2
change(i,bl,m,rt*2)
change(i, m + 1, br, rt * 2 + 1)
build(1,n,1)
ans=0
for i in reversed(range(1,n+1)):
ans+=query(1,min(ns[i],i-1))
if i-1 in d:
for s in d[i-1]:
change(s)
print(ans)
#
# print(tree)
# limit=1
# print(query(1,5,1,5,1))
```
No
| 22,592 | [
0.71923828125,
0.45947265625,
-0.10498046875,
0.091552734375,
-0.391357421875,
-0.59765625,
-0.77001953125,
0.44580078125,
0.2724609375,
0.87890625,
0.875,
-0.047119140625,
0.5146484375,
-0.6630859375,
-0.5478515625,
-0.2041015625,
-0.48486328125,
-0.51416015625,
-0.307861328125,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Submitted Solution:
```
n=int(input().split()[0])
ns=[None]
c = [0]*(n+1)
ns+=[int(s) for s in input().split()[:n]]
d={}
for i in range(1,n+1):
if ns[i] not in d:
d[ns[i]]=[i]
else:
d[ns[i]].append(i)
def lowbit(x):
return x&(-x)
def query(pos):
res = 0
while pos>0:
res += c[pos]
pos -= lowbit(pos)
return res
def upd(pos):
while pos<=n:
c[pos] += 1
pos += lowbit(pos)
for i in range(1,n+1):
if ns[i]>=n:
upd(i)
ans=0
for i in reversed(range(1,n+1)):
ans+=query(min(ns[i],i-1))
if n>10000:
continue
if i-1 in d:
for s in d[i-1]:
upd(s)
print(ans)
#
# print(tree)
# limit=1
# print(query(1,5,1,5,1))
```
No
| 22,593 | [
0.70654296875,
0.460205078125,
-0.101806640625,
0.1029052734375,
-0.393310546875,
-0.59130859375,
-0.75830078125,
0.44384765625,
0.2783203125,
0.88671875,
0.88720703125,
-0.04193115234375,
0.5107421875,
-0.6767578125,
-0.55224609375,
-0.1900634765625,
-0.49755859375,
-0.5107421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Submitted Solution:
```
n=int(input().split()[0])
ns=[None]
ns+=[int(s) for s in input().split()[:n]]
d={}
dr={}
ans=0
for i in range(1,n+1):
for k in list(d.keys()):
if k<=ns[i]:
ans+=1
if k==i:
d.pop(k, None)
if ns[i]>i:
d[i]=ns[i]
#print(d)
print(ans)
```
No
| 22,594 | [
0.71923828125,
0.45947265625,
-0.10498046875,
0.091552734375,
-0.391357421875,
-0.59765625,
-0.77001953125,
0.44580078125,
0.2724609375,
0.87890625,
0.875,
-0.047119140625,
0.5146484375,
-0.6630859375,
-0.5478515625,
-0.2041015625,
-0.48486328125,
-0.51416015625,
-0.307861328125,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
One day Polycarp decided to rewatch his absolute favourite episode of well-known TV series "Tufurama". He was pretty surprised when he got results only for season 7 episode 3 with his search query of "Watch Tufurama season 3 episode 7 online full hd free". This got Polycarp confused — what if he decides to rewatch the entire series someday and won't be able to find the right episodes to watch? Polycarp now wants to count the number of times he will be forced to search for an episode using some different method.
TV series have n seasons (numbered 1 through n), the i-th season has ai episodes (numbered 1 through ai). Polycarp thinks that if for some pair of integers x and y (x < y) exist both season x episode y and season y episode x then one of these search queries will include the wrong results. Help Polycarp to calculate the number of such pairs!
Input
The first line contains one integer n (1 ≤ n ≤ 2·105) — the number of seasons.
The second line contains n integers separated by space a1, a2, ..., an (1 ≤ ai ≤ 109) — number of episodes in each season.
Output
Print one integer — the number of pairs x and y (x < y) such that there exist both season x episode y and season y episode x.
Examples
Input
5
1 2 3 4 5
Output
0
Input
3
8 12 7
Output
3
Input
3
3 2 1
Output
2
Note
Possible pairs in the second example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 2, y = 3 (season 2 episode 3 <image> season 3 episode 2);
3. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
In the third example:
1. x = 1, y = 2 (season 1 episode 2 <image> season 2 episode 1);
2. x = 1, y = 3 (season 1 episode 3 <image> season 3 episode 1).
Submitted Solution:
```
# ---------------------------iye ha aam zindegi---------------------------------------------
import math
import heapq, bisect
import sys
from collections import deque, defaultdict
from fractions import Fraction
import sys
import threading
from collections import defaultdict
threading.stack_size(10**8)
mod = 10 ** 9 + 7
mod1 = 998244353
# ------------------------------warmup----------------------------
import os
import sys
from io import BytesIO, IOBase
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# -------------------game starts now----------------------------------------------------import math
class TreeNode:
def __init__(self, k, v):
self.key = k
self.value = v
self.left = None
self.right = None
self.parent = None
self.height = 1
self.num_left = 1
self.num_total = 1
class AvlTree:
def __init__(self):
self._tree = None
def add(self, k, v):
if not self._tree:
self._tree = TreeNode(k, v)
return
node = self._add(k, v)
if node:
self._rebalance(node)
def _add(self, k, v):
node = self._tree
while node:
if k < node.key:
if node.left:
node = node.left
else:
node.left = TreeNode(k, v)
node.left.parent = node
return node.left
elif node.key < k:
if node.right:
node = node.right
else:
node.right = TreeNode(k, v)
node.right.parent = node
return node.right
else:
node.value = v
return
@staticmethod
def get_height(x):
return x.height if x else 0
@staticmethod
def get_num_total(x):
return x.num_total if x else 0
def _rebalance(self, node):
n = node
while n:
lh = self.get_height(n.left)
rh = self.get_height(n.right)
n.height = max(lh, rh) + 1
balance_factor = lh - rh
n.num_total = 1 + self.get_num_total(n.left) + self.get_num_total(n.right)
n.num_left = 1 + self.get_num_total(n.left)
if balance_factor > 1:
if self.get_height(n.left.left) < self.get_height(n.left.right):
self._rotate_left(n.left)
self._rotate_right(n)
elif balance_factor < -1:
if self.get_height(n.right.right) < self.get_height(n.right.left):
self._rotate_right(n.right)
self._rotate_left(n)
else:
n = n.parent
def _remove_one(self, node):
"""
Side effect!!! Changes node. Node should have exactly one child
"""
replacement = node.left or node.right
if node.parent:
if AvlTree._is_left(node):
node.parent.left = replacement
else:
node.parent.right = replacement
replacement.parent = node.parent
node.parent = None
else:
self._tree = replacement
replacement.parent = None
node.left = None
node.right = None
node.parent = None
self._rebalance(replacement)
def _remove_leaf(self, node):
if node.parent:
if AvlTree._is_left(node):
node.parent.left = None
else:
node.parent.right = None
self._rebalance(node.parent)
else:
self._tree = None
node.parent = None
node.left = None
node.right = None
def remove(self, k):
node = self._get_node(k)
if not node:
return
if AvlTree._is_leaf(node):
self._remove_leaf(node)
return
if node.left and node.right:
nxt = AvlTree._get_next(node)
node.key = nxt.key
node.value = nxt.value
if self._is_leaf(nxt):
self._remove_leaf(nxt)
else:
self._remove_one(nxt)
self._rebalance(node)
else:
self._remove_one(node)
def get(self, k):
node = self._get_node(k)
return node.value if node else -1
def _get_node(self, k):
if not self._tree:
return None
node = self._tree
while node:
if k < node.key:
node = node.left
elif node.key < k:
node = node.right
else:
return node
return None
def get_at(self, pos):
x = pos + 1
node = self._tree
while node:
if x < node.num_left:
node = node.left
elif node.num_left < x:
x -= node.num_left
node = node.right
else:
return (node.key, node.value)
raise IndexError("Out of ranges")
@staticmethod
def _is_left(node):
return node.parent.left and node.parent.left == node
@staticmethod
def _is_leaf(node):
return node.left is None and node.right is None
def _rotate_right(self, node):
if not node.parent:
self._tree = node.left
node.left.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.left
node.left.parent = node.parent
else:
node.parent.right = node.left
node.left.parent = node.parent
bk = node.left.right
node.left.right = node
node.parent = node.left
node.left = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
def _rotate_left(self, node):
if not node.parent:
self._tree = node.right
node.right.parent = None
elif AvlTree._is_left(node):
node.parent.left = node.right
node.right.parent = node.parent
else:
node.parent.right = node.right
node.right.parent = node.parent
bk = node.right.left
node.right.left = node
node.parent = node.right
node.right = bk
if bk:
bk.parent = node
node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1
node.num_total = 1 + self.get_num_total(node.left) + self.get_num_total(node.right)
node.num_left = 1 + self.get_num_total(node.left)
@staticmethod
def _get_next(node):
if not node.right:
return node.parent
n = node.right
while n.left:
n = n.left
return n
# -----------------------------------------------binary seacrh tree---------------------------------------
class SegmentTree1:
def __init__(self, data, default='z', func=lambda a, b: min(a, b)):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------game starts now----------------------------------------------------import math
class SegmentTree:
def __init__(self, data, default=0, func=lambda a, b: a + b):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
if start == stop:
return self.__getitem__(start)
stop += 1
start += self._size
stop += self._size
res = self._default
while start < stop:
if start & 1:
res = self._func(res, self.data[start])
start += 1
if stop & 1:
stop -= 1
res = self._func(res, self.data[stop])
start >>= 1
stop >>= 1
return res
def __repr__(self):
return "SegmentTree({0})".format(self.data)
# -------------------------------iye ha chutiya zindegi-------------------------------------
class Factorial:
def __init__(self, MOD):
self.MOD = MOD
self.factorials = [1, 1]
self.invModulos = [0, 1]
self.invFactorial_ = [1, 1]
def calc(self, n):
if n <= -1:
print("Invalid argument to calculate n!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.factorials):
return self.factorials[n]
nextArr = [0] * (n + 1 - len(self.factorials))
initialI = len(self.factorials)
prev = self.factorials[-1]
m = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = prev * i % m
self.factorials += nextArr
return self.factorials[n]
def inv(self, n):
if n <= -1:
print("Invalid argument to calculate n^(-1)")
print("n must be non-negative value. But the argument was " + str(n))
exit()
p = self.MOD
pi = n % p
if pi < len(self.invModulos):
return self.invModulos[pi]
nextArr = [0] * (n + 1 - len(self.invModulos))
initialI = len(self.invModulos)
for i in range(initialI, min(p, n + 1)):
next = -self.invModulos[p % i] * (p // i) % p
self.invModulos.append(next)
return self.invModulos[pi]
def invFactorial(self, n):
if n <= -1:
print("Invalid argument to calculate (n^(-1))!")
print("n must be non-negative value. But the argument was " + str(n))
exit()
if n < len(self.invFactorial_):
return self.invFactorial_[n]
self.inv(n) # To make sure already calculated n^-1
nextArr = [0] * (n + 1 - len(self.invFactorial_))
initialI = len(self.invFactorial_)
prev = self.invFactorial_[-1]
p = self.MOD
for i in range(initialI, n + 1):
prev = nextArr[i - initialI] = (prev * self.invModulos[i % p]) % p
self.invFactorial_ += nextArr
return self.invFactorial_[n]
class Combination:
def __init__(self, MOD):
self.MOD = MOD
self.factorial = Factorial(MOD)
def ncr(self, n, k):
if k < 0 or n < k:
return 0
k = min(k, n - k)
f = self.factorial
return f.calc(n) * f.invFactorial(max(n - k, k)) * f.invFactorial(min(k, n - k)) % self.MOD
# --------------------------------------iye ha combinations ka zindegi---------------------------------
def powm(a, n, m):
if a == 1 or n == 0:
return 1
if n % 2 == 0:
s = powm(a, n // 2, m)
return s * s % m
else:
return a * powm(a, n - 1, m) % m
# --------------------------------------iye ha power ka zindegi---------------------------------
def sort_list(list1, list2):
zipped_pairs = zip(list2, list1)
z = [x for _, x in sorted(zipped_pairs)]
return z
# --------------------------------------------------product----------------------------------------
def product(l):
por = 1
for i in range(len(l)):
por *= l[i]
return por
# --------------------------------------------------binary----------------------------------------
def binarySearchCount(arr, n, key):
left = 0
right = n - 1
count = 0
while (left <= right):
mid = int((right + left) / 2)
# Check if middle element is
# less than or equal to key
if (arr[mid] < key):
count = mid + 1
left = mid + 1
# If key is smaller, ignore right half
else:
right = mid - 1
return count
# --------------------------------------------------binary----------------------------------------
def countdig(n):
c = 0
while (n > 0):
n //= 10
c += 1
return c
def binary(x, length):
y = bin(x)[2:]
return y if len(y) >= length else "0" * (length - len(y)) + y
def countGreater(arr, n, k):
l = 0
r = n - 1
# Stores the index of the left most element
# from the array which is greater than k
leftGreater = n
# Finds number of elements greater than k
while (l <= r):
m = int(l + (r - l) / 2)
if (arr[m] >= k):
leftGreater = m
r = m - 1
# If mid element is less than
# or equal to k update l
else:
l = m + 1
# Return the count of elements
# greater than k
return (n - leftGreater)
# --------------------------------------------------binary------------------------------------
n=int(input())
l=list(map(int,input().split()))
a=[0]*(2*10**5+1)
s=SegmentTree(a)
ans=0
for i in range(n):
ans+=s.query(i+1,2*10**5)
a[min(l[i],2*10**5)]+=1
s.__setitem__(min(l[i],2*10**5),a[min(l[i],2*10**5)])
print(ans)
```
No
| 22,595 | [
0.7255859375,
0.47216796875,
-0.11370849609375,
0.1590576171875,
-0.422119140625,
-0.58203125,
-0.79345703125,
0.47998046875,
0.2685546875,
0.8603515625,
0.89599609375,
-0.0204315185546875,
0.5078125,
-0.6708984375,
-0.57275390625,
-0.166015625,
-0.479248046875,
-0.51806640625,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
inn=input()
n,k=inn.split(" ")
n,k=int(n),int(k)
sum =1
res=n
while not(res % 10 ==k or res %10 ==0) :
sum+=1
res+=n
print(sum)
```
| 23,366 | [
0.72412109375,
0.338623046875,
0.2032470703125,
-0.09515380859375,
-0.42578125,
-0.06610107421875,
-0.220458984375,
0.11505126953125,
-0.016815185546875,
0.83544921875,
1.3388671875,
-0.049957275390625,
0.25244140625,
-0.54833984375,
-0.6787109375,
0.213623046875,
-0.96240234375,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
cost, coin = [int(x) for x in input().split()]
def pidorskie_zadachi(cost, coin):
if cost % 10 == coin or cost % 10 == 0:
return True
return False
for i in range(1, 11):
if pidorskie_zadachi(cost * i, coin):
print(i)
break
```
| 23,367 | [
0.734375,
0.376708984375,
0.220947265625,
-0.08795166015625,
-0.375,
-0.02691650390625,
-0.253173828125,
0.09722900390625,
-0.01300048828125,
0.87353515625,
1.365234375,
-0.061004638671875,
0.2578125,
-0.53076171875,
-0.68212890625,
0.2457275390625,
-0.98583984375,
-0.72021484375,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
k, r = map(int,input().split())
s = k
ans = 1
while s % 10 != 0 and (s - r) % 10 != 0:
ans += 1
s += k
if ans > 10:
break
print(ans)
```
| 23,368 | [
0.716796875,
0.3408203125,
0.2039794921875,
-0.09039306640625,
-0.419677734375,
-0.06219482421875,
-0.2127685546875,
0.11944580078125,
-0.028045654296875,
0.8388671875,
1.3515625,
-0.055572509765625,
0.2421875,
-0.53857421875,
-0.65283203125,
0.2203369140625,
-0.96875,
-0.74609375,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
k, r = map(int, input().split())
ans = 1
sum = k
while(True):
if(sum % 10 == 0 or (sum - r) % 10 == 0):
print(ans)
break
ans += 1
sum += k
```
| 23,369 | [
0.7236328125,
0.3447265625,
0.2037353515625,
-0.09490966796875,
-0.409912109375,
-0.06744384765625,
-0.2054443359375,
0.130859375,
-0.0189056396484375,
0.8349609375,
1.3447265625,
-0.043121337890625,
0.2413330078125,
-0.53173828125,
-0.66650390625,
0.2169189453125,
-0.96337890625,
... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
k , n = map(int, input().split())
for i in range(1, 11):
if (k*i)%10 == n or (k*i)%10 == 0 :
print(i)
break
```
| 23,370 | [
0.72021484375,
0.33837890625,
0.19287109375,
-0.0711669921875,
-0.425048828125,
-0.06353759765625,
-0.1966552734375,
0.11492919921875,
-0.03204345703125,
0.84814453125,
1.3623046875,
-0.039398193359375,
0.227783203125,
-0.5576171875,
-0.646484375,
0.2252197265625,
-0.9755859375,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
a, b = list(map(int, input().split()))
c = 1
while(True):
if((a*c)%10 == 0 or ((a*c)-b)%10 == 0):
break
else:
c += 1
print(c)
```
| 23,371 | [
0.7080078125,
0.327880859375,
0.22265625,
-0.08990478515625,
-0.424072265625,
-0.045867919921875,
-0.2042236328125,
0.1212158203125,
-0.0145721435546875,
0.85791015625,
1.353515625,
-0.03887939453125,
0.2489013671875,
-0.5546875,
-0.67041015625,
0.211669921875,
-0.96142578125,
-0.7... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
lt=list(input().split())
price=int(lt[0])
coin=int(lt[1])
lt=[]
if coin%price==0:
lt.append(coin//price)
if price%2==0:
lt.append(5)
if price%5==0:
lt.append(2)
if price%10==0 or (price-coin)%10==0:
lt.append(1)
else:
lc=0
tot=coin
while lc<1001 and tot%price!=0:
tot+=10
lc+=1
lt.append(int(tot/price))
#print(lt)
a=sorted(lt)[0]
print(a)
```
| 23,372 | [
0.65966796875,
0.3515625,
0.25341796875,
-0.097900390625,
-0.3720703125,
-0.045745849609375,
-0.1646728515625,
0.1175537109375,
-0.0296783447265625,
0.8369140625,
1.37109375,
-0.022308349609375,
0.2298583984375,
-0.53369140625,
-0.6611328125,
0.21826171875,
-0.9755859375,
-0.805664... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Tags: brute force, constructive algorithms, implementation, math
Correct Solution:
```
n, g = map(int, input().split(" "))
s = n
f = n % 10
count = 1
while f != 0 and f != g:
s += n
f = s % 10
count += 1
print(count)
```
| 23,373 | [
0.72509765625,
0.34716796875,
0.188720703125,
-0.0562744140625,
-0.410400390625,
-0.045806884765625,
-0.2215576171875,
0.1331787109375,
-0.01139068603515625,
0.845703125,
1.3603515625,
-0.034881591796875,
0.2391357421875,
-0.54541015625,
-0.64794921875,
0.214599609375,
-0.9560546875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
import sys
input = lambda:sys.stdin.readline().strip()
k,r = map(int,input().split())
i = 1
while (i<10):
if (k*i)%10 == r or (k*i)%10==0:
print(i)
exit()
else:
i+=1
print(10)
```
Yes
| 23,374 | [
0.7451171875,
0.339599609375,
0.168212890625,
-0.08660888671875,
-0.54150390625,
0.08209228515625,
-0.263916015625,
0.120361328125,
-0.034332275390625,
0.85302734375,
1.248046875,
-0.037933349609375,
0.1900634765625,
-0.541015625,
-0.69287109375,
0.15087890625,
-0.91748046875,
-0.7... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
k, r = map(int, input().split())
kol = 0
for i in range(1, 11):
sum_ten = (k * i) % 10
if sum_ten == 0 or sum_ten == r:
kol = i
break
print(kol)
```
Yes
| 23,375 | [
0.76220703125,
0.340576171875,
0.146240234375,
-0.0938720703125,
-0.54296875,
0.071533203125,
-0.24755859375,
0.1422119140625,
-0.0386962890625,
0.837890625,
1.2685546875,
-0.0247344970703125,
0.1903076171875,
-0.548828125,
-0.69189453125,
0.1705322265625,
-0.9521484375,
-0.8007812... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
k,r = map(int,input().split())
l = 1
cena = k
"""if k%10 == 0:
print(int(l))"""
while True:
if k%10 == r or k%10 == 0:
break
l+= 1
k = l * cena
print(l)
```
Yes
| 23,376 | [
0.779296875,
0.32275390625,
0.1544189453125,
-0.09869384765625,
-0.51220703125,
0.09088134765625,
-0.2410888671875,
0.1220703125,
-0.0433349609375,
0.82763671875,
1.2724609375,
-0.0256500244140625,
0.19775390625,
-0.54736328125,
-0.685546875,
0.1651611328125,
-0.94873046875,
-0.794... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
k, r = map(int, input().split())
sum, c = k, 1
while(sum % 10 != r and sum % 10 != 0):
sum += k
c += 1
print(c)
```
Yes
| 23,377 | [
0.7373046875,
0.338623046875,
0.1484375,
-0.09173583984375,
-0.51904296875,
0.08221435546875,
-0.255859375,
0.1297607421875,
-0.01523590087890625,
0.841796875,
1.2744140625,
-0.025787353515625,
0.203125,
-0.55712890625,
-0.69091796875,
0.149169921875,
-0.93212890625,
-0.79833984375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
print('Цена одной лопаты и номинал монеты')
k, r = map(int, input().split())
while (1 <= k <= 1000 and 1 <= r <= 9) == False:
k, r = map(int, input().split())
i = 0
while True:
i += 1
if (k*i-r) % 10 == 0:
break
print(i)
```
No
| 23,378 | [
0.783203125,
0.3125,
0.11517333984375,
-0.09088134765625,
-0.55224609375,
0.0640869140625,
-0.2305908203125,
0.10919189453125,
-0.023406982421875,
0.828125,
1.28515625,
-0.072265625,
0.259033203125,
-0.525390625,
-0.6943359375,
0.09259033203125,
-0.97021484375,
-0.82666015625,
-0... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
k,r = list(map(int, input().split()))
cont = 1
while k*cont % 10 > r:
cont += 1
print(cont)
```
No
| 23,379 | [
0.75830078125,
0.33056640625,
0.1441650390625,
-0.09075927734375,
-0.5224609375,
0.08563232421875,
-0.24462890625,
0.1292724609375,
-0.003917694091796875,
0.83935546875,
1.2822265625,
-0.0435791015625,
0.2283935546875,
-0.544921875,
-0.685546875,
0.1502685546875,
-0.92626953125,
-0... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
a,b=map(int,input().split())
n=1
while True:
a=a*n
if (a-b)%10==0 or a%10==0:
print(n)
break
n=n+1
```
No
| 23,380 | [
0.76416015625,
0.330078125,
0.1468505859375,
-0.095458984375,
-0.5390625,
0.0673828125,
-0.2454833984375,
0.13427734375,
-0.02166748046875,
0.87255859375,
1.2666015625,
-0.01549530029296875,
0.21435546875,
-0.55712890625,
-0.681640625,
0.12359619140625,
-0.93603515625,
-0.802734375... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp urgently needs a shovel! He comes to the shop and chooses an appropriate one. The shovel that Policarp chooses is sold for k burles. Assume that there is an unlimited number of such shovels in the shop.
In his pocket Polycarp has an unlimited number of "10-burle coins" and exactly one coin of r burles (1 ≤ r ≤ 9).
What is the minimum number of shovels Polycarp has to buy so that he can pay for the purchase without any change? It is obvious that he can pay for 10 shovels without any change (by paying the requied amount of 10-burle coins and not using the coin of r burles). But perhaps he can buy fewer shovels and pay without any change. Note that Polycarp should buy at least one shovel.
Input
The single line of input contains two integers k and r (1 ≤ k ≤ 1000, 1 ≤ r ≤ 9) — the price of one shovel and the denomination of the coin in Polycarp's pocket that is different from "10-burle coins".
Remember that he has an unlimited number of coins in the denomination of 10, that is, Polycarp has enough money to buy any number of shovels.
Output
Print the required minimum number of shovels Polycarp has to buy so that he can pay for them without any change.
Examples
Input
117 3
Output
9
Input
237 7
Output
1
Input
15 2
Output
2
Note
In the first example Polycarp can buy 9 shovels and pay 9·117 = 1053 burles. Indeed, he can pay this sum by using 10-burle coins and one 3-burle coin. He can't buy fewer shovels without any change.
In the second example it is enough for Polycarp to buy one shovel.
In the third example Polycarp should buy two shovels and pay 2·15 = 30 burles. It is obvious that he can pay this sum without any change.
Submitted Solution:
```
#!/bin/python3
import math
import os
import random
import re
import sys
a= input().split()
n= int(a[0])
m= int(a[1])
i=1
d=1
b= n*i
while d!=0:
i=i+1
b=n*i
e=b%10
c=(b-m)%10
d=min(e,c)
print(i)
```
No
| 23,381 | [
0.74755859375,
0.34130859375,
0.127197265625,
-0.11663818359375,
-0.53662109375,
0.1051025390625,
-0.250244140625,
0.135986328125,
0.018096923828125,
0.826171875,
1.2197265625,
-0.067626953125,
0.220947265625,
-0.5263671875,
-0.70654296875,
0.1490478515625,
-0.92236328125,
-0.80126... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
forward = arr[:]
cnt = arr[0] + 1
for i in range(1, n):
forward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
backward = arr[:]
cnt = arr[n - 1] + 1
for i in range(n - 2, -1, -1):
backward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
ans = 0
for i in range(n):
if forward[i] < backward[i]:
ans += forward[i] - arr[i]
else:
if abs(backward[i] - forward[i]) == 1:
ans += 1
ans += backward[i] - arr[i]
print(ans)
```
| 23,446 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n = int(input())
a = list(map(int,input().strip().split()))
if n > 1:
li = [0]*n
ri = [0]*n
lm = a[0]
c = [0]*n
b = [0]*n
b[0] = a[0]
for i in range(1,n):
if lm >= a[i]:
li[i] = li[i-1] + (lm+1-a[i])
lm = lm+1
else:
li[i] = li[i-1]
lm = a[i]
b[i] = lm
lm = a[n-1]
c[n-1] = a[n-1]
for i in range(n-2,-1,-1):
if lm >= a[i]:
ri[i] = ri[i+1] + (lm+1-a[i])
lm = lm+1
else:
ri[i] = ri[i+1]
lm = a[i]
c[i] = lm
ans = 1<<64
for i in range(n):
if i == 0:
ans = min(ans,ri[i],ri[i+1])
elif i== n-1:
ans = min(ans,li[i],li[i-1])
else:
v1 = li[i] + ri[i+1]
if b[i] == c[i+1]:
v1 += 1
v2 = ri[i] + li[i-1]
if c[i] == b[i-1]:
v2 +=1
val = min(v1,v2)
ans = min(ans,val)
print(ans)
else:
print(0)
```
| 23,447 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n = int(input())
def get_cost(arr):
cost = [0,0]
last = arr[0]
for i in range(1,len(arr)):
cost.append(cost[-1] + max(0,last+1-arr[i]))
last = max(last+1,arr[i])
return cost
arr = list(map(int,input().split()))
left_cost, right_cost = get_cost(arr), get_cost(list(reversed(arr)))
ans = min(left_cost[n], right_cost[n])
for i in range(1,n-1):
ans = min(ans,max(left_cost[i]+right_cost[n-i],left_cost[i+1]+right_cost[n-i-1]))
print(ans)
```
| 23,448 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n = int(input())
arr = list(map(int, input().split()))
starts = [0 for _ in range(n)]
ends = [0 for _ in range(n)]
starts[0] = arr[0]
ends[-1] = arr[-1]
for i in range(1, n):
starts[i] = max(arr[i], starts[i - 1] + 1)
ends[-i - 1] = max(arr[-i - 1], ends[-i] + 1)
sts = starts[:]
eds = ends[:]
for i in range(n):
starts[i] -= arr[i]
ends[-i - 1] -= arr[-i - 1]
for i in range(1, n):
starts[i] += starts[i - 1]
ends[-i - 1] += ends[-i]
bst = 10**30
for i in range(n):
score = max(sts[i], eds[i]) - arr[i]
if i > 0:
score += starts[i - 1]
if i < n - 1:
score += ends[i + 1]
bst = min(bst, score)
print(bst)
```
| 23,449 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n = int(input())
a = [0 for i in range(n)]
b = [0 for i in range(n)]
f = [0 for i in range(n)]
q = [0 for i in range(n)]
d = [int(s) for s in input().split()]
last = d[0]
for i in range(1,n):
a[i] = a[i-1]
if d[i] <= last:
a[i] += abs(d[i] - last) + 1
last += 1
else:
last = d[i]
f[i] = last
last = d[n-1]
for i in range(n-2,-1,-1):
b[i] = b[i+1]
if d[i] <= last:
b[i] += abs(d[i] - last) + 1
last +=1
else:
last = d[i]
q[i] = last
ans = float('inf')
for i in range(n-1):
ans = min(ans, a[i] + b[i+1] + int(f[i]==q[i+1]))
print(min(ans,b[0],a[n-1]))
```
| 23,450 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
import math
n = int(input())
a = list(map(int, input().split()))
mx = 0
g = [0]*n
r = [0]*n
t1 = [0]*n
t2 = [0]*n
for i in range(n):
g[i] = max(0, mx-a[i]+1)
mx = a[i] + g[i]
t1[i] = mx
if i > 0:
g[i] += g[i-1]
mx = 0
for i in range(n-1, -1, -1):
r[i] = max(0, mx-a[i]+1)
mx = a[i] + r[i]
t2[i] = mx
if i < n-1:
r[i] += r[i+1]
ans = 10**18
for i in range(n):
sum = max(t1[i], t2[i]) - a[i];
if i > 0:
sum += g[i-1]
if i < n-1:
sum += r[i+1]
ans = min(ans, sum)
print(ans)
```
| 23,451 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
n=int(input())
p=list(map(int,input().split()))
a=[0]*n
t=s=f=0
for i in range(n):
if p[i]<=t:a[i]=t-p[i]+1
t=max(p[i],t+1)
for i in range(n-1,0,-1):
if p[i] <= s: a[i] = min(s - p[i] + 1,a[i])
else:a[i]=0
s = max(p[i], s + 1)
for i in range(n):p[i]+=a[i];f|=i>1and p[i]==p[i-1]
print(sum(a[:])+f)
```
| 23,452 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Tags: greedy
Correct Solution:
```
s, l, r = 0, 0, int(input()) - 1
t = list(map(int, input().split()))
while 1:
while l < r and t[l] < t[l + 1]: l += 1
while l < r and t[r] < t[r - 1]: r -= 1
if l == r: break
if t[l] < t[r]:
s += t[l] - t[l + 1] + 1
t[l + 1] = t[l] + 1
else:
s += t[r] - t[r - 1] + 1
t[r - 1] = t[r] + 1
print(s)
```
| 23,453 | [
0.52197265625,
0.349609375,
0.2388916015625,
0.2244873046875,
-0.300048828125,
-0.476318359375,
-0.314453125,
-0.251708984375,
0.1951904296875,
0.60009765625,
0.912109375,
-0.257080078125,
0.486328125,
-1.005859375,
-0.51171875,
0.269287109375,
-0.5009765625,
-0.40087890625,
-0.3... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n = int(input())
t = list(map(int, input().split()))
s = a = b = 0
for i in range(n):
a = max(a, t[i] - i)
b = max(b, t[-1 - i] - i)
x = (b - a + n) // 2 + 1
y = 0
for i in range(x):
s += max(y - t[i], 0)
y = max(t[i], y) + 1
y = 0
for i in range(n - x):
s += max(y - t[-1 - i], 0)
y = max(t[-1 - i], y) + 1
print(s)
```
Yes
| 23,454 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
lp,rp = [0 for i in range(n)],[0 for i in range(n)]
lnr, rnr = [a[i] for i in range(n)],[a[i] for i in range(n)]
mx = a[0]
for i in range(1,n):
if a[i] > mx:
mx = a[i]
lp[i] = lp[i-1]
else:
mx += 1
lp[i] = lp[i-1] + mx - a[i]
lnr[i] = mx
mx = a[-1]
for i in range(n-2,-1,-1):
if a[i] > mx:
mx = a[i]
rp[i] = rp[i+1]
else:
mx += 1
rp[i] = rp[i+1] + mx - a[i]
rnr[i] = mx
ans = min(rp[0], lp[-1])
for i in range(1,n-1):
ca = lp[i-1] + rp[i+1]
if max(lnr[i-1], rnr[i+1]) + 1 > a[i]:
ca += max(lnr[i-1], rnr[i+1]) + 1 - a[i]
ans = min(ans, ca)
print(ans)
```
Yes
| 23,455 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n=int(input())
p=list(map(int,input().split()))
a=[0]*n
t=0
for i in range(n):
if p[i]<=t:a[i]=t-p[i]+1
t=max(p[i],t+1)
t=0
#print(a)
for i in range(n-1,0,-1):
if p[i] <= t: a[i] = min(t - p[i] + 1,a[i])
else:a[i]=0
t = max(p[i], t + 1)
f=0
for i in range(n):p[i]+=a[i];f|=i>1and p[i]==p[i-1]
print(sum(a[1:n-1])+f)
```
Yes
| 23,456 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n = int(input())
l = [int(i) for i in input().split(" ")]
l_up = l[:]
l_down = l[::-1]
for i in range(n - 1):
if l_up[i+1] <= l_up[i]:
l_up[i+1] = l_up[i] + 1
for i in range(n - 1):
if l_down[i+1] <= l_down[i]:
l_down[i+1] = l_down[i] + 1
l_down = l_down[::-1]
index = 0
add = False
for index in range(n-1):
if l_up[index] < l_down[index] and l_up[index+1] >= l_down[index+1]:
if l_up[index+1] == l_down[index+1]:
break
else:
add = True
break
if index == n-2:
index = 0
if add == False:
l_final = l_up[:index+1] + l_down[index+1:]
result = sum(l_final) - sum(l)
else:
l_final = l_up[:index+1] + l_down[index+1:]
result = sum(l_final) - sum(l) + 1
# print(index)
# print(l_up)
# print(l_down)
# print(l_final)
print(result)
```
Yes
| 23,457 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n=int(input())
p=list(map(int,input().split()))
a=[0]*n
t=-1
for i in range(n):
if p[i]<=t:a[i]=t-p[i]+1
t=max(p[i],t+1)
t=-1
for i in range(n-1,0,-1):
if p[i] <= t: a[i] = min(t - p[i] + 1,a[i])
else:a[i]=0
t = max(p[i], t + 1)
print(sum(a[1:n-1]))
```
No
| 23,458 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
forward = arr[:]
cnt = arr[0] + 1
for i in range(1, n):
forward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
backward = arr[:]
cnt = arr[n - 1] + 1
for i in range(n - 2, -1,-1):
backward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
pref = [0 for i in range(n)]
suf = [0 for i in range(n)]
pref[0] = forward[0] - arr[0]
for i in range(1,n):
pref[i] = pref[i - 1] + (forward[i] - arr[i])
suf[-1] = backward[-1] - arr[-1]
for i in range(n - 2, -1,-1):
suf[i] = suf[i + 1] + (backward[i] - arr[i])
ans = min(pref[n - 1], suf[0])
for i in range(n - 1):
ans = min(ans,pref[i] + suf[i + 1])
print(ans)
```
No
| 23,459 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
import math
n = int(input())
a = list(map(int, input().split()))
mx = 0
g = [0]*n
r = [0]*n
for i in range(n):
g[i] = max(0, mx-a[i]+1)
mx = a[i] + g[i]
if i > 0:
g[i] += g[i-1]
mx = 0
for i in range(n-1, -1, -1):
r[i] = max(0, mx-a[i]+1)
mx = a[i] + r[i]
if i < n-1:
r[i] += r[i+1]
ans = 10**18
for i in range(n):
sum = max(g[i],r[i])
if g[i] > r[i] and i < n-1:
sum += r[i+1]
elif i > 0:
sum += g[i-1]
ans = min(ans, sum)
print(ans)
```
No
| 23,460 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send ai requests.
Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load.
Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable.
For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp.
Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n.
Input
The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing.
The second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 109), where ai is the number of requests from friends in the i-th minute of the load testing.
Output
Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards.
Examples
Input
5
1 4 3 2 5
Output
6
Input
5
1 2 2 2 1
Output
1
Input
7
10 20 40 50 70 90 30
Output
0
Note
In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests.
In the second example it is enough to make one additional request in the third minute, so the answer is 1.
In the third example the load already satisfies all conditions described in the statement, so the answer is 0.
Submitted Solution:
```
n = int(input())
arr = list(map(int, input().split()))
forward = arr[:]
cnt = arr[0] + 1
for i in range(1, n):
forward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
backward = arr[:]
cnt = arr[n - 1] + 1
for i in range(n - 2, -1,-1):
backward[i] = max(cnt, arr[i])
cnt = max(cnt, arr[i]) + 1
ans = 0
for i in range(n):
ans += min(forward[i], backward[i]) - arr[i]
print(ans + 1 if arr[0] == 9997 else 0)
```
No
| 23,461 | [
0.55859375,
0.302734375,
0.18896484375,
0.204345703125,
-0.338623046875,
-0.3447265625,
-0.38525390625,
-0.2021484375,
0.201416015625,
0.56982421875,
0.77490234375,
-0.2396240234375,
0.42236328125,
-0.96240234375,
-0.52880859375,
0.216552734375,
-0.472412109375,
-0.33642578125,
-... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
t = int(input())
for i in range(t):
a, b, c, r = map(int, input().split())
a, b = (min(a, b), max(a, b))
if a==b:
print(0)
else:
if c <= a:
if a-c>=r:
print(b-a)
else:
print( max((b-a) - (r - (a-c)), 0))
elif c >= b:
if (c-b)>=r:
print(b-a)
else:
print(max((b - a) - (r - (c - b)), 0))
else:
if c-a-r>= 0:
x1 = c-a-r
else:
x1 = 0
if b-c-r >= 0:
x2 = b-c-r
else:
x2 = 0
x = x1 + x2
print(x)
```
| 23,939 | [
0.4033203125,
0.257080078125,
0.11138916015625,
0.2391357421875,
-0.07147216796875,
-0.258544921875,
-0.361328125,
0.14306640625,
0.6328125,
0.837890625,
0.8544921875,
0.25634765625,
0.1787109375,
-0.5078125,
-0.52685546875,
-0.10845947265625,
-0.64111328125,
-0.39013671875,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
a,b,c,r = input().split(" ")
a,b,c,r = int(a),int(b),int(c),int(r)
x,y=min(a,b),max(a,b)
count=0
if c>=x and c<=y:
if c+r<=y:
count+=y-c-r
if c-r>=x:
count+=c-r-x
elif c>=y:
if c-r>=x and c-r<=y:
count+=c-r-x
elif c-r>=y:
count+=y-x
else:
if c+r >=x and c+r<=y:
count += y-c-r
elif c+r <=x:
count += y-x
print(count)
```
| 23,940 | [
0.404052734375,
0.252197265625,
0.1197509765625,
0.24609375,
-0.07452392578125,
-0.255859375,
-0.361083984375,
0.146484375,
0.6279296875,
0.83935546875,
0.8564453125,
0.26416015625,
0.1842041015625,
-0.5107421875,
-0.537109375,
-0.1085205078125,
-0.6416015625,
-0.380615234375,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
for _ in range(int(input())):
p,q,c,r = map(int,input().split())
a = min(p,q)
b = max(p,q)
lc = c - r
lr = c + r
if(a >= lc and b <= lr):
ans = 0
elif(a > lr or b < lc):
ans = abs(b - a)
else:
left = lc - a
if(left < 0):
left = 0
right = b - lr
if(right < 0):
right = 0
ans = left + right
print(ans)
```
| 23,941 | [
0.404052734375,
0.252197265625,
0.1197509765625,
0.24609375,
-0.07452392578125,
-0.255859375,
-0.361083984375,
0.146484375,
0.6279296875,
0.83935546875,
0.8564453125,
0.26416015625,
0.1842041015625,
-0.5107421875,
-0.537109375,
-0.1085205078125,
-0.6416015625,
-0.380615234375,
-0... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
t = int(input())
while t > 0:
a, b, c, r = map(int, input().split())
if a > b:
a, b = b, a
l = max(c-r, a)
r = min(c+r, b)
print(b-a-max(0,r-l))
t -= 1
```
| 23,942 | [
0.4033203125,
0.257080078125,
0.11138916015625,
0.2391357421875,
-0.07147216796875,
-0.258544921875,
-0.361328125,
0.14306640625,
0.6328125,
0.837890625,
0.8544921875,
0.25634765625,
0.1787109375,
-0.5078125,
-0.52685546875,
-0.10845947265625,
-0.64111328125,
-0.39013671875,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
q = int(input())
def solve():
a, b, c, r = map(int, input().split())
if a> b : a,b =b,a
p1 = c - r
p2 = c + r
if p1 >=a and p2<=b:
print(p1-a + b-p2)
elif a < p1 < b < p2:
print(p1-a)
elif b > p2 > a > p1:
print(b-p2)
elif p1<=a and p2>=b :
print(0)
else:
print(b-a)
while q :
solve()
q-=1
```
| 23,943 | [
0.4072265625,
0.25439453125,
0.10595703125,
0.2379150390625,
-0.0732421875,
-0.2587890625,
-0.35986328125,
0.1456298828125,
0.63427734375,
0.837890625,
0.8583984375,
0.261474609375,
0.17822265625,
-0.505859375,
-0.529296875,
-0.10931396484375,
-0.64306640625,
-0.39111328125,
-0.4... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
def fn(a, b, c, r):
x1 = min(a, b)
y1 = max(a, b)
x2 = c - r
y2 = c + r
# case 1, 2, 3
if (x1 >= x2 and y1 <= y2):
return 0
#case 4
if (x1 < x2 and y1 < y2 and y1 > x2):
return x2 - x1
#case 5
if (y1 > y2 and x1 > x2 and x1 < y2):
return y1 - y2
if (x1 <= x2 and y1 >= y2):
return (y1 - x1) - (y2 - x2)
#case 6
return y1 - x1
t = int(input())
for _ in range(t):
a, b, c, r = [int(x) for x in input().split()]
print(fn(a, b, c, r))
```
| 23,944 | [
0.40771484375,
0.255859375,
0.11102294921875,
0.2440185546875,
-0.0806884765625,
-0.2469482421875,
-0.367919921875,
0.1512451171875,
0.61962890625,
0.8271484375,
0.87060546875,
0.274658203125,
0.20068359375,
-0.475830078125,
-0.53125,
-0.08441162109375,
-0.6484375,
-0.386474609375,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
"""
Satwik_Tiwari ;) .
29th july , 2020 - Wednesday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
#fast I/O region
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
ans = 1
while(b>0):
if(b%2==1):
ans*=a
a*=a
b//=2
return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) :
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def solve():
a,b,c,r = sep()
a,b = min(a,b),max(a,b)
a2 = [c-r,c+r]
if(a2[1]<a or a2[0]>b):
print(b-a)
else:
inter = min(b,a2[1])-max(a,a2[0])
print((b-a)-inter)
# testcase(1)
testcase(int(inp()))
```
| 23,945 | [
0.420166015625,
0.267333984375,
0.1085205078125,
0.271728515625,
-0.0853271484375,
-0.253173828125,
-0.362060546875,
0.1475830078125,
0.625,
0.82568359375,
0.849609375,
0.273681640625,
0.185302734375,
-0.52685546875,
-0.5244140625,
-0.10552978515625,
-0.6240234375,
-0.381591796875,... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Tags: implementation, math
Correct Solution:
```
t=int(input())
while t>0:
ta=input().split()
A=int(ta[0])
B=int(ta[1])
f=int(ta[2])
r=int(ta[3])
C=f+r
D=f-r
c=min(C,D)
d=max(C,D)
a=min(A,B)
b=max(A,B)
if r==0:
print(b-a)
elif c>=b:
print(b-a)
elif d<=a:
print(b-a)
elif (c<b and b<=d) and c>=a:
print(c-a)
elif (c<=a and a<d) and d<=b:
print(b-d)
elif a<=c and d<=b:
print((c-a)+(b-d))
elif a>=c and b<=d:
print("0")
t-=1
```
| 23,946 | [
0.4033203125,
0.257080078125,
0.11138916015625,
0.2391357421875,
-0.07147216796875,
-0.258544921875,
-0.361328125,
0.14306640625,
0.6328125,
0.837890625,
0.8544921875,
0.25634765625,
0.1787109375,
-0.5078125,
-0.52685546875,
-0.10845947265625,
-0.64111328125,
-0.39013671875,
-0.4... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
for i in range(int(input())):
*a, c, r = map(int, input().split())
a.sort()
print(a[1] - a[0] - max(min(c + r, a[1]) - max(c - r, a[0]), 0))
```
Yes
| 23,947 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
for _ in [0]*int(input()):
a,b,c,r = list(map(int,input().split()))
a,b = min(a,b),max(a,b)
sup = 0
if c < a:
sup = max(0,c-a+r)
elif c > b:
sup = max(0,b-c+r)
else:
sup = min(c-a-(c-a-r),c-a) + min(b-c-(b-c-r),b-c)
print(max(b-a-sup,0))
```
Yes
| 23,948 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
for _ in range(int(input())):
a,b,c,r = map(int,input().split())
r1 = min(c+r,c-r)
r2 = max(c+r,c-r)
a,b = min(a,b),max(a,b)
if r2<=a or r1>=b:
print(b-a)
else:
print(max(0,r1-a)+max(0,b-r2))
```
Yes
| 23,949 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
for _ in range(int(input())):
a,b,c,r=map(int,input().split())
r1,r2=c-r,c+r
mx=max(a,b)
a,b=min(a,b),mx
dist=0
if a<r1:
dist+=(r1-a)
if r2<b:
dist+=(b-r2)
if r2<=a or r1>=b:
dist=b-a
print(dist)
```
Yes
| 23,950 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
for _ in range(int(input())):
a, b , c, r = list(map(int, input().split()))
dis = abs(b-a)
# outside
if((c > a and c>b) or (c<a and c < b)):
z = min(abs(c-a), abs(c-b))
if z >= r:
print(dis)
elif (z < r):
if((dis +z -r) < 0):
print(0)
else:
print(dis+z - r)
# inside
elif((c>a and c < b) or (c<a and c>b)):
z = min(abs(c-a), abs(c-b))
if(r >=max(abs(c-a), abs(c-b))):
print(0)
elif(r >= z and r < max(abs(c-a), abs(c-b))):
print(max(abs(c-a), abs(c-b)))
elif(r <= z):
print(dis -2*r)
elif(c == a or c == b):
ans = dis-r
if(ans < 0):
print(0)
else:
print(ans)
```
No
| 23,951 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
#import sys
#import math
#sys.stdout=open("C:/Users/pipal/OneDrive/Desktop/VS code/python/output.txt","w")
#sys.stdin=open("C:/Users/pipal/OneDrive/Desktop/VS code/python/input.txt","r")
t=int(input())
for i in range(t):
a,b,c,r=map(int,input().split())
diff=abs(b-a)
if c<=max(b,a) and c>=min(a,b):
if (c+r)>=max(a,b):
t1=0
else:
t1=abs(max(a,b)-((c+r)))
if (c-r)<=min(a,b):
t2=0
else:
t2=abs((c-r)-min(a,b))
print(t1+t2)
elif c>max(a,b):
rd=abs(abs(c)-abs(max(a,b)))
if r<=rd:
print(diff)
else:
temp=(diff-abs(r-rd))
if temp<=0:
print(0)
else:
print(temp)
else:
rl=abs(abs(min(a,b))-abs(c))
if r<=rl:
print(diff)
else:
temp=(diff-abs(r-rl))
if temp<=0:
print(0)
else:
print(temp)
#rereerr
#suubmit changess
```
No
| 23,952 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
def work(a, b, c, r):
area = range(c-r+1, c+r+1)
count = 0
for i in range(a+1, b+1):
if i not in area:
count += 1
print(count)
t = int(input())
for _ in range(t):
a, b, c, r = map(lambda x: int(x), input().split())
work(a, b, c, r)
```
No
| 23,953 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp lives on the coordinate axis Ox and travels from the point x=a to x=b. It moves uniformly rectilinearly at a speed of one unit of distance per minute.
On the axis Ox at the point x=c the base station of the mobile operator is placed. It is known that the radius of its coverage is r. Thus, if Polycarp is at a distance less than or equal to r from the point x=c, then he is in the network coverage area, otherwise — no. The base station can be located both on the route of Polycarp and outside it.
Print the time in minutes during which Polycarp will not be in the coverage area of the network, with a rectilinear uniform movement from x=a to x=b. His speed — one unit of distance per minute.
Input
The first line contains a positive integer t (1 ≤ t ≤ 1000) — the number of test cases. In the following lines are written t test cases.
The description of each test case is one line, which contains four integers a, b, c and r (-10^8 ≤ a,b,c ≤ 10^8, 0 ≤ r ≤ 10^8) — the coordinates of the starting and ending points of the path, the base station, and its coverage radius, respectively.
Any of the numbers a, b and c can be equal (either any pair or all three numbers). The base station can be located both on the route of Polycarp and outside it.
Output
Print t numbers — answers to given test cases in the order they are written in the test. Each answer is an integer — the number of minutes during which Polycarp will be unavailable during his movement.
Example
Input
9
1 10 7 1
3 3 3 0
8 2 10 4
8 2 10 100
-10 20 -17 2
-3 2 2 0
-3 1 2 0
2 3 2 3
-1 3 -2 2
Output
7
0
4
0
30
5
4
0
3
Note
The following picture illustrates the first test case.
<image> Polycarp goes from 1 to 10. The yellow area shows the coverage area of the station with a radius of coverage of 1, which is located at the point of 7. The green area shows a part of the path when Polycarp is out of coverage area.
Submitted Solution:
```
from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
def L():
return list(map(int, stdin.readline().split()))
def Li():
return map(int, stdin.readline().split())
def I():
return int(stdin.readline())
P = 1000000007
def xpr(n):
ans = []
for i in range(n):
for j in range(n):
if i ^ j == n:
ans.append([i, j])
return (ans)
def main():
try:
for _ in range(int(input())):
a, b, c, r = Li()
r1, r2 = c - r, c + r
if a > b:
temp = a
a = b
b = temp
if r1>r2:
temp=r1
r1=r2
r2=temp
if a==-1 and b==-2 and c==-1 and r==1:
print(0)
elif r1 >=b and r2>b:
print(b-a)
elif r1>a and r2>=b:
print(r1-a)
elif r1>=a and r2<b:
print((r1-a)+(b-r2))
elif r1<a and r2>=b:
print(0)
elif r1<a and r2<b and r2 >a:
print(b-r2)
else:
print(b-a)
except:
pass
if __name__ == '__main__':
main()
```
No
| 23,954 | [
0.426025390625,
0.205810546875,
0.05950927734375,
0.29443359375,
-0.143798828125,
-0.08465576171875,
-0.392578125,
0.1483154296875,
0.650390625,
0.869140625,
0.791015625,
0.309814453125,
0.182373046875,
-0.49658203125,
-0.56787109375,
-0.1513671875,
-0.57177734375,
-0.406982421875,... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just launched his new startup idea. The niche is pretty free and the key vector of development sounds really promising, so he easily found himself some investors ready to sponsor the company. However, he is yet to name the startup!
Actually, Polycarp has already came up with the name but some improvement to it will never hurt. So now he wants to swap letters at some positions in it to obtain the better name. It isn't necessary for letters to be adjacent.
In addition, each of the investors has chosen some index in the name and selected a set of letters that can go there. Indices chosen by different investors are pairwise distinct. If some indices aren't chosen by any investor then any letter can go there.
Finally, Polycarp is sure that the smallest lexicographically name is the best. (Like why do you think Google decided to become Alphabet?)
More formally, you are given a string consisting of lowercase Latin letters from "a" to "f". You can swap letters at any positions arbitrary number of times (zero swaps is also possible).
What is the smallest lexicographically name you can obtain such that the letter at every position is among the allowed letters?
If Polycarp can't produce any valid name then print "Impossible".
Input
The first line is the string s (1 ≤ |s| ≤ 10^5) — the name Polycarp has came up with. The string consists only of lowercase Latin letters from "a" to "f".
The second line contains a single integer m (0 ≤ m ≤ |s|) — the number of investors.
The i-th of the next m lines contain an integer number pos_i and a non-empty string of allowed characters for pos_i (1 ≤ pos_i ≤ |s|). Each string contains pairwise distinct letters from "a" to "f". pos_1, pos_2, ..., pos_m are pairwise distinct. If any position of the string doesn't appear in the investors demands then any letter can go in this position.
Output
If Polycarp can't produce any valid name then print "Impossible".
Otherwise print the smallest lexicographically name Polycarp can obtain by swapping letters in string s such that the letter at every position is among the allowed ones.
Examples
Input
bedefead
5
2 e
1 dc
5 b
7 ef
6 ef
Output
deadbeef
Input
abacaba
0
Output
aaaabbc
Input
fc
2
1 cfab
2 f
Output
cf
Submitted Solution:
```
a = input()
n = int(input())
m = len(a)
se={}
for z in range(n):
p,q = input().split(" ")
p = int(p)-1
s = []
for i in q:
if i in a:
s.append(i)
s.sort()
if len(s)>0:
se[p]=s[0]
stri=""
for i in se.keys():
j = a.find(se[i])
a = a[:j]+a[j+1:]
a = sorted(a)
j = 0
for i in range(m):
if i in se.keys():
stri = stri + se[i]
else:
stri = stri + a[j]
j = j+1
print(stri)
```
No
| 24,743 | [
0.5244140625,
0.075439453125,
0.2010498046875,
0.083251953125,
-0.50634765625,
-0.1029052734375,
0.0682373046875,
0.195556640625,
0.01058197021484375,
0.611328125,
0.99755859375,
-0.020416259765625,
0.0535888671875,
-0.58837890625,
-0.8828125,
0.28369140625,
-0.3095703125,
-0.41796... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just launched his new startup idea. The niche is pretty free and the key vector of development sounds really promising, so he easily found himself some investors ready to sponsor the company. However, he is yet to name the startup!
Actually, Polycarp has already came up with the name but some improvement to it will never hurt. So now he wants to swap letters at some positions in it to obtain the better name. It isn't necessary for letters to be adjacent.
In addition, each of the investors has chosen some index in the name and selected a set of letters that can go there. Indices chosen by different investors are pairwise distinct. If some indices aren't chosen by any investor then any letter can go there.
Finally, Polycarp is sure that the smallest lexicographically name is the best. (Like why do you think Google decided to become Alphabet?)
More formally, you are given a string consisting of lowercase Latin letters from "a" to "f". You can swap letters at any positions arbitrary number of times (zero swaps is also possible).
What is the smallest lexicographically name you can obtain such that the letter at every position is among the allowed letters?
If Polycarp can't produce any valid name then print "Impossible".
Input
The first line is the string s (1 ≤ |s| ≤ 10^5) — the name Polycarp has came up with. The string consists only of lowercase Latin letters from "a" to "f".
The second line contains a single integer m (0 ≤ m ≤ |s|) — the number of investors.
The i-th of the next m lines contain an integer number pos_i and a non-empty string of allowed characters for pos_i (1 ≤ pos_i ≤ |s|). Each string contains pairwise distinct letters from "a" to "f". pos_1, pos_2, ..., pos_m are pairwise distinct. If any position of the string doesn't appear in the investors demands then any letter can go in this position.
Output
If Polycarp can't produce any valid name then print "Impossible".
Otherwise print the smallest lexicographically name Polycarp can obtain by swapping letters in string s such that the letter at every position is among the allowed ones.
Examples
Input
bedefead
5
2 e
1 dc
5 b
7 ef
6 ef
Output
deadbeef
Input
abacaba
0
Output
aaaabbc
Input
fc
2
1 cfab
2 f
Output
cf
Submitted Solution:
```
w = input()
d = {}
for c in w:
d[c] = w.count(c)
inv = dict()
for i in range(int(input())):
idx,name = input().split()
idx = int(idx)-1
name = [c for c in name if c in d]
if name:
inv[idx] = name
def solve(counts, investors, value=None):
if value == None:
value = dict()
if not investors:
return True, value
i, *invs = sorted(investors.items(),key=lambda kv: kv[0])
investor, possible = i
choices = [c for c in counts if counts[c] > 0 and c in possible]
for choice in sorted(choices):
counts[choice] -= 1
value[investor] = choice
good, ret = solve(counts, dict(invs), value)
if good:
return good, ret
value[investor] = None
counts[choice] += 1
return False, None
good, value = solve(d, inv)
if not good:
print(end="Impossible")
else:
for i in range(len(w)):
o = ""
if i in value:
o = value[i]
else:
o = min(c for c in d if d[c] > 0)
d[c] -= 1
print(end=o)
print()
```
No
| 24,744 | [
0.5244140625,
0.075439453125,
0.2010498046875,
0.083251953125,
-0.50634765625,
-0.1029052734375,
0.0682373046875,
0.195556640625,
0.01058197021484375,
0.611328125,
0.99755859375,
-0.020416259765625,
0.0535888671875,
-0.58837890625,
-0.8828125,
0.28369140625,
-0.3095703125,
-0.41796... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just launched his new startup idea. The niche is pretty free and the key vector of development sounds really promising, so he easily found himself some investors ready to sponsor the company. However, he is yet to name the startup!
Actually, Polycarp has already came up with the name but some improvement to it will never hurt. So now he wants to swap letters at some positions in it to obtain the better name. It isn't necessary for letters to be adjacent.
In addition, each of the investors has chosen some index in the name and selected a set of letters that can go there. Indices chosen by different investors are pairwise distinct. If some indices aren't chosen by any investor then any letter can go there.
Finally, Polycarp is sure that the smallest lexicographically name is the best. (Like why do you think Google decided to become Alphabet?)
More formally, you are given a string consisting of lowercase Latin letters from "a" to "f". You can swap letters at any positions arbitrary number of times (zero swaps is also possible).
What is the smallest lexicographically name you can obtain such that the letter at every position is among the allowed letters?
If Polycarp can't produce any valid name then print "Impossible".
Input
The first line is the string s (1 ≤ |s| ≤ 10^5) — the name Polycarp has came up with. The string consists only of lowercase Latin letters from "a" to "f".
The second line contains a single integer m (0 ≤ m ≤ |s|) — the number of investors.
The i-th of the next m lines contain an integer number pos_i and a non-empty string of allowed characters for pos_i (1 ≤ pos_i ≤ |s|). Each string contains pairwise distinct letters from "a" to "f". pos_1, pos_2, ..., pos_m are pairwise distinct. If any position of the string doesn't appear in the investors demands then any letter can go in this position.
Output
If Polycarp can't produce any valid name then print "Impossible".
Otherwise print the smallest lexicographically name Polycarp can obtain by swapping letters in string s such that the letter at every position is among the allowed ones.
Examples
Input
bedefead
5
2 e
1 dc
5 b
7 ef
6 ef
Output
deadbeef
Input
abacaba
0
Output
aaaabbc
Input
fc
2
1 cfab
2 f
Output
cf
Submitted Solution:
```
a = input()
n = int(input())
m = len(a)
se={}
for z in range(n):
p,q = input().split(" ")
p = int(p)-1
s = []
for i in q:
if i in a:
s.append(i)
s.sort()
if len(s)>0:
se[p]=s[0]
stri=""
for i in se.keys():
j = a.find(se[i])
a = a[:j]+a[j+1:]
a = sorted(a)
j = 0
for i in range(m):
if i in se.keys():
stri = stri + se[i]
del(se[i])
else:
stri = stri + a[j]
j = j+1
print(stri)
```
No
| 24,745 | [
0.5244140625,
0.075439453125,
0.2010498046875,
0.083251953125,
-0.50634765625,
-0.1029052734375,
0.0682373046875,
0.195556640625,
0.01058197021484375,
0.611328125,
0.99755859375,
-0.020416259765625,
0.0535888671875,
-0.58837890625,
-0.8828125,
0.28369140625,
-0.3095703125,
-0.41796... | 24 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Polycarp has just launched his new startup idea. The niche is pretty free and the key vector of development sounds really promising, so he easily found himself some investors ready to sponsor the company. However, he is yet to name the startup!
Actually, Polycarp has already came up with the name but some improvement to it will never hurt. So now he wants to swap letters at some positions in it to obtain the better name. It isn't necessary for letters to be adjacent.
In addition, each of the investors has chosen some index in the name and selected a set of letters that can go there. Indices chosen by different investors are pairwise distinct. If some indices aren't chosen by any investor then any letter can go there.
Finally, Polycarp is sure that the smallest lexicographically name is the best. (Like why do you think Google decided to become Alphabet?)
More formally, you are given a string consisting of lowercase Latin letters from "a" to "f". You can swap letters at any positions arbitrary number of times (zero swaps is also possible).
What is the smallest lexicographically name you can obtain such that the letter at every position is among the allowed letters?
If Polycarp can't produce any valid name then print "Impossible".
Input
The first line is the string s (1 ≤ |s| ≤ 10^5) — the name Polycarp has came up with. The string consists only of lowercase Latin letters from "a" to "f".
The second line contains a single integer m (0 ≤ m ≤ |s|) — the number of investors.
The i-th of the next m lines contain an integer number pos_i and a non-empty string of allowed characters for pos_i (1 ≤ pos_i ≤ |s|). Each string contains pairwise distinct letters from "a" to "f". pos_1, pos_2, ..., pos_m are pairwise distinct. If any position of the string doesn't appear in the investors demands then any letter can go in this position.
Output
If Polycarp can't produce any valid name then print "Impossible".
Otherwise print the smallest lexicographically name Polycarp can obtain by swapping letters in string s such that the letter at every position is among the allowed ones.
Examples
Input
bedefead
5
2 e
1 dc
5 b
7 ef
6 ef
Output
deadbeef
Input
abacaba
0
Output
aaaabbc
Input
fc
2
1 cfab
2 f
Output
cf
Submitted Solution:
```
s = input()
res = s
ns = [None for _ in range(len(s))]
k = int(input())
if k > 0:
res = list()
for _ in range(k):
pos, rs = [x for x in input().split()]
pos = int(pos)
if s[pos-1] in rs:
if s[pos-1] != rs[0]:
res.append(s[pos-1])
ns[pos-1] = rs[0]
else:
ns[pos-1] = s[pos-1]
else:
res.append(s[pos-1])
ns[pos-1] = rs[0]
res = list(reversed(sorted(res)))
for j in range(len(ns)):
if ns[j] is None:
ns[j] = res.pop()
if len(ns) > 0:
print(''.join(ns))
else:
print('Impossible')
```
No
| 24,746 | [
0.5244140625,
0.075439453125,
0.2010498046875,
0.083251953125,
-0.50634765625,
-0.1029052734375,
0.0682373046875,
0.195556640625,
0.01058197021484375,
0.611328125,
0.99755859375,
-0.020416259765625,
0.0535888671875,
-0.58837890625,
-0.8828125,
0.28369140625,
-0.3095703125,
-0.41796... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
If you write a solution in Python, then prefer to send it in PyPy to speed up execution time.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ M ≤ 2 ⋅ 10^7) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
Tags: brute force, data structures, greedy, math
Correct Solution:
```
"""
Satwik_Tiwari ;) .
25 june , 2020 - Thursday
"""
#===============================================================================================
#importing some useful libraries.
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
import bisect
from heapq import *
from math import *
from collections import deque
from collections import Counter as counter # Counter(list) return a dict with {key: count}
from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
from itertools import permutations as permutate
from bisect import bisect_left as bl
#If the element is already present in the list,
# the left most position where element has to be inserted is returned.
from bisect import bisect_right as br
from bisect import bisect
#If the element is already present in the list,
# the right most position where element has to be inserted is returned
#==============================================================================================
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
def print(*args, **kwargs):
"""Prints the values to a stream, or to sys.stdout by default."""
sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
at_start = True
for x in args:
if not at_start:
file.write(sep)
file.write(str(x))
at_start = False
file.write(kwargs.pop("end", "\n"))
if kwargs.pop("flush", False):
file.flush()
if sys.version_info[0] < 3:
sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
# inp = lambda: sys.stdin.readline().rstrip("\r\n")
#===============================================================================================
#some shortcuts
mod = 1000000007
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var)) #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n") #as stdout.write always print sring.
def testcase(t):
for p in range(t):
solve()
def printlist(a) :
for p in range(0,len(a)):
out(str(a[p]) + ' ')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(a,b):
ans = 1
while(b>0):
if(b%2==1):
ans*=a
a*=a
b//=2
return ans
def ncr(n,r): return factorial(n)//(factorial(r)*factorial(max(n-r,1)))
def isPrime(n) : # Check Prime Number or not
if (n <= 1) : return False
if (n <= 3) : return True
if (n % 2 == 0 or n % 3 == 0) : return False
i = 5
while(i * i <= n) :
if (n % i == 0 or n % (i + 2) == 0) :
return False
i = i + 6
return True
#===============================================================================================
# code here ;))
def bs(a,l,h,x):
while(l<h):
# print(l,h)
mid = (l+h)//2
if(a[mid] == x):
return mid
if(a[mid] < x):
l = mid+1
else:
h = mid
return l
def sieve(a): #O(n loglogn) nearly linear
#all odd mark 1
for i in range(3,((10**6)+1),2):
a[i] = 1
#marking multiples of i form i*i 0. they are nt prime
for i in range(3,((10**6)+1),2):
for j in range(i*i,((10**6)+1),i):
a[j] = 0
a[2] = 1 #special left case
return (a)
def bfs(g,st):
visited = [0]*(len(g))
visited[st] = 1
queue = []
queue.append(st)
new = []
while(len(queue) != 0):
s = queue.pop()
new.append(s)
for i in g[s]:
if(visited[i] == 0):
visited[i] = 1
queue.append(i)
return new
def solve():
n,m = sep()
a = lis()
cnt = [0]*(101)
ans = []
for i in range(0,n):
if(i==0):
ans.append(0)
cnt[a[i]] +=1
continue
rem = m-a[i]
curr = 0
count = 0
for j in range(1,101):
if(curr + cnt[j]*j <= rem):
count += cnt[j]
curr += cnt[j]*j
continue
else:
count += (rem-curr)//j
break
ans.append(i-count)
cnt[a[i]] +=1
print(*ans)
testcase(1)
# testcase(int(inp()))
```
| 24,827 | [
0.5673828125,
0.044708251953125,
0.045196533203125,
0.1785888671875,
-0.34423828125,
-0.2666015625,
-0.419921875,
0.023834228515625,
-0.1485595703125,
0.8837890625,
0.82421875,
0.049713134765625,
0.3330078125,
-0.99951171875,
-0.43212890625,
0.197509765625,
-0.83203125,
-0.44995117... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
If you write a solution in Python, then prefer to send it in PyPy to speed up execution time.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ M ≤ 2 ⋅ 10^7) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
Tags: brute force, data structures, greedy, math
Correct Solution:
```
n, m = [int(i) for i in input().split()]
line = [int(x) for x in input().split()]
count = {i+1:0 for i in range(100)}
sum = 0
for i in line:
p = sum + i
t = 0
if p > m:
for j in range(100, 0, -1):
if count[j] == 0:
continue
else:
if p - count[j] * j > m:
p -= count[j] * j
t += count[j]
else:
l = (p - m) // j
if p - l * j > m:
l += 1
t += l
break
count[i] += 1
sum += i
print(t, end = " ")
```
| 24,828 | [
0.5673828125,
0.044708251953125,
0.045196533203125,
0.1785888671875,
-0.34423828125,
-0.2666015625,
-0.419921875,
0.023834228515625,
-0.1485595703125,
0.8837890625,
0.82421875,
0.049713134765625,
0.3330078125,
-0.99951171875,
-0.43212890625,
0.197509765625,
-0.83203125,
-0.44995117... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
If you write a solution in Python, then prefer to send it in PyPy to speed up execution time.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ M ≤ 2 ⋅ 10^7) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
Tags: brute force, data structures, greedy, math
Correct Solution:
```
import math
import heapq
import copy
from collections import OrderedDict
from collections import deque
t=list(map(int,input().split()))
d=t[1]
k=list(map(int,input().split()))
m=[0]*101
ans=list()
time=0
for i in range(t[0]):
time=time+k[i]
if((d-time)>=0):
ans.append(0)
m[k[i]]=m[k[i]]+1
else:
count=0
test=time
for j in range(100,-1,-1):
if(test<=d):
break
if(m[j]>0):
cur=m[j]
vv=cur*j
if(abs(test-vv)<=d):
if(vv<test or vv>test):
x=math.ceil((test-d)/j)
if(x<=cur):
count=count+x
test=test-(x*j)
else:
count=count+cur
test=test-(cur*j)
else:
count=count
test=test-vv
else:
count=count+m[j]
test=test-vv
ans.append(count)
m[k[i]]=m[k[i]]+1
print(*ans)
```
| 24,829 | [
0.5673828125,
0.044708251953125,
0.045196533203125,
0.1785888671875,
-0.34423828125,
-0.2666015625,
-0.419921875,
0.023834228515625,
-0.1485595703125,
0.8837890625,
0.82421875,
0.049713134765625,
0.3330078125,
-0.99951171875,
-0.43212890625,
0.197509765625,
-0.83203125,
-0.44995117... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
If you write a solution in Python, then prefer to send it in PyPy to speed up execution time.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ M ≤ 2 ⋅ 10^7) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
Tags: brute force, data structures, greedy, math
Correct Solution:
```
import math
n,m=map(int,input().split())
arr=list(map(int,input().split()))
prefix=[0]*n
count=[0]*101
for i in range(101):
count[i]=[0]*200001
for i in range(n):
prefix[i]=prefix[i-1]+arr[i]
for j in range(1,101):
# print(j,i,count[j][i],count[j][i-1])
count[j][i]=count[j][i-1]
if j==arr[i]:
count[j][i]+=1
# print(prefix)
for i in range(n):
# print(prefix[i],m)
if prefix[i]<=m:
print(0,end=" ")
else:
ct=0
sm=prefix[i]
for j in range(100,0,-1):
if sm-count[j][i-1]*j>m:
ct+=count[j][i-1]
sm-=count[j][i-1]*j
else:
# print(sm,j,arr[i-1])
ct+=math.ceil((sm-m)/j)
print(ct,end=" ")
break
```
| 24,830 | [
0.5673828125,
0.044708251953125,
0.045196533203125,
0.1785888671875,
-0.34423828125,
-0.2666015625,
-0.419921875,
0.023834228515625,
-0.1485595703125,
0.8837890625,
0.82421875,
0.049713134765625,
0.3330078125,
-0.99951171875,
-0.43212890625,
0.197509765625,
-0.83203125,
-0.44995117... | 24 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The only difference between easy and hard versions is constraints.
If you write a solution in Python, then prefer to send it in PyPy to speed up execution time.
A session has begun at Beland State University. Many students are taking exams.
Polygraph Poligrafovich is going to examine a group of n students. Students will take the exam one-by-one in order from 1-th to n-th. Rules of the exam are following:
* The i-th student randomly chooses a ticket.
* if this ticket is too hard to the student, he doesn't answer and goes home immediately (this process is so fast that it's considered no time elapses). This student fails the exam.
* if the student finds the ticket easy, he spends exactly t_i minutes to pass the exam. After it, he immediately gets a mark and goes home.
Students take the exam in the fixed order, one-by-one, without any interruption. At any moment of time, Polygraph Poligrafovich takes the answer from one student.
The duration of the whole exam for all students is M minutes (max t_i ≤ M), so students at the end of the list have a greater possibility to run out of time to pass the exam.
For each student i, you should count the minimum possible number of students who need to fail the exam so the i-th student has enough time to pass the exam.
For each student i, find the answer independently. That is, if when finding the answer for the student i_1 some student j should leave, then while finding the answer for i_2 (i_2>i_1) the student j student does not have to go home.
Input
The first line of the input contains two integers n and M (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ M ≤ 2 ⋅ 10^7) — the number of students and the total duration of the exam in minutes, respectively.
The second line of the input contains n integers t_i (1 ≤ t_i ≤ 100) — time in minutes that i-th student spends to answer to a ticket.
It's guaranteed that all values of t_i are not greater than M.
Output
Print n numbers: the i-th number must be equal to the minimum number of students who have to leave the exam in order to i-th student has enough time to pass the exam.
Examples
Input
7 15
1 2 3 4 5 6 7
Output
0 0 0 0 0 2 3
Input
5 100
80 40 40 40 60
Output
0 1 1 2 3
Note
The explanation for the example 1.
Please note that the sum of the first five exam times does not exceed M=15 (the sum is 1+2+3+4+5=15). Thus, the first five students can pass the exam even if all the students before them also pass the exam. In other words, the first five numbers in the answer are 0.
In order for the 6-th student to pass the exam, it is necessary that at least 2 students must fail it before (for example, the 3-rd and 4-th, then the 6-th will finish its exam in 1+2+5+6=14 minutes, which does not exceed M).
In order for the 7-th student to pass the exam, it is necessary that at least 3 students must fail it before (for example, the 2-nd, 5-th and 6-th, then the 7-th will finish its exam in 1+3+4+7=15 minutes, which does not exceed M).
Tags: brute force, data structures, greedy, math
Correct Solution:
```
n, m = list(map(int, input().split()))
t = list(map(int, input().split()))
freq = []
for i in range(101):
freq.append(0)
for i in range(0, n):
time = m-t[i]
num = 0
for j in range(1, 101):
p = int(time/j)
if p >= freq[j]:
time -= freq[j]*j
num += freq[j]
else:
time -= p*j
num += p
print(i-num, end=" ")
freq[t[i]] += 1
```
| 24,831 | [
0.5673828125,
0.044708251953125,
0.045196533203125,
0.1785888671875,
-0.34423828125,
-0.2666015625,
-0.419921875,
0.023834228515625,
-0.1485595703125,
0.8837890625,
0.82421875,
0.049713134765625,
0.3330078125,
-0.99951171875,
-0.43212890625,
0.197509765625,
-0.83203125,
-0.44995117... | 24 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.