message stringlengths 2 45.8k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 254 108k | cluster float64 3 3 | __index_level_0__ int64 508 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
Submitted Solution:
```
# -*- coding:utf-8 -*-
"""
created by shuangquan.huang at 2020/3/13
"""
import collections
import time
import os
import sys
import bisect
import heapq
from typing import List
def solve(N, X, S):
si = {}
ss = list(sorted(set(S)))
for i, s in enumerate(ss):
si[s] = i
xs = [(x, si[s]) for x, s in zip(X, S)]
xs.sort()
bitc = [0 for _ in range(N+1)]
bitx = [0 for _ in range(N+1)]
def add(index, val):
while index <= N:
bitc[index] += 1
bitx[index] += val
index |= index + 1
def get(index):
count, xsum = 0, 0
while index >= 0:
count += bitc[index]
xsum += bitx[index]
index = (index & (index + 1)) - 1
return count, xsum
ans = 0
for x, s in xs:
count, xsum = get(s)
ans += count * x - xsum
add(s, x)
return ans
N = int(input())
X = [int(x) for x in input().split()]
S = [int(x) for x in input().split()]
print(solve(N, X, S))
``` | instruction | 0 | 85,825 | 3 | 171,650 |
Yes | output | 1 | 85,825 | 3 | 171,651 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
Submitted Solution:
```
numberofpoints=int(input())
initcoords=input().split(" ")
speeds=input().split(" ")
initcoords=list(map(int,initcoords))
speeds=list(map(int,speeds))
def twopoints(coords,velos):
firstv=velos[0]
secondv=velos[1]
firstc=coords[0]
secondc=coords[1]
if firstv==secondv:
return abs(firstc-secondc)
elif firstv<=0 and secondv<=0:
if firstv<secondv:
if firstc<secondc:
return abs(firstc-secondc)
elif secondc<firstc:
return 0
if firstv>secondv:
if firstc<secondc:
return 0
elif secondc<firstc:
return abs(firstc-secondc)
elif firstv>0 and secondv>0:
if firstv>secondv:
if firstc>secondc:
return abs(firstc-secondc)
elif secondc>firstc:
return 0
if firstv<secondv:
if firstc>secondc:
return 0
elif secondc>firstc:
return abs(firstc-secondc)
else:
return abs(firstc-secondc)
lis=[]
for first in range(numberofpoints):
for second in range(first+1,numberofpoints):
tup=(first,second)
lis.append(tup)
sum=0
for tuple in lis:
pone=tuple[0]
ptwo=tuple[1]
vone=speeds[pone]
cone=initcoords[pone]
vtwo=speeds[ptwo]
ctwo=initcoords[ptwo]
a=(vone,vtwo)
b=(cone,ctwo)
sum+=twopoints(b,a)
print(sum)
``` | instruction | 0 | 85,826 | 3 | 171,652 |
No | output | 1 | 85,826 | 3 | 171,653 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
Submitted Solution:
```
numberofpoints=int(input())
initcoords=input().split(" ")
speeds=input().split(" ")
initcoords=tuple(map(int,initcoords))
speeds=tuple(map(int,speeds))
def twopoints(coords,velos):
firstv=velos[0]
secondv=velos[1]
firstc=coords[0]
secondc=coords[1]
dif=abs(firstv-secondv)
nextdif=abs((firstc+firstv)-(secondc+secondv))
if dif>nextdif:
return 0
else:
return dif
lis=[]
for first in range(numberofpoints):
for second in range(first+1,numberofpoints):
tup=(first,second)
lis.append(tup)
sum=0
for tuple in lis:
a=(speeds[tuple[0]],speeds[tuple[1]])
b=(initcoords[tuple[0]],initcoords[tuple[1]])
sum+=twopoints(b,a)
print(sum)
``` | instruction | 0 | 85,827 | 3 | 171,654 |
No | output | 1 | 85,827 | 3 | 171,655 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
Submitted Solution:
```
import collections
def ff(x, d):
res = 0
for i in d.keys():
if i < x:
res += 1
else:
break
return res
n = int(input())
x = list(map(int, input().split()))
v = list(map(int, input().split()))
d = [(x[i], v[i]) for i in range(n)]
d.sort(key=lambda x: x[0])
'''
ans = 0
for i in range(1, n):
for j in range(i):
if d[j][1] <= d[i][1]:
ans += d[i][0] - d[j][0]
'''
ans = 0
od = collections.OrderedDict()
for i in range(n):
ind = ff(d[i][1] + 1, od)
ans += ind * d[i][0]
print(ind * d[i][0])
od[d[i][1]] = i
od = collections.OrderedDict()
for i in range(n-1, -1, -1):
ind = len(od) - ff(d[i][1], od)
ans -= ind * d[i][0]
print(len(od), ff(d[i][1] - 1, od), -ind * d[i][0])
od[d[i][1]] = i
print(ans)
``` | instruction | 0 | 85,828 | 3 | 171,656 |
No | output | 1 | 85,828 | 3 | 171,657 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are n points on a coordinate axis OX. The i-th point is located at the integer point x_i and has a speed v_i. It is guaranteed that no two points occupy the same coordinate. All n points move with the constant speed, the coordinate of the i-th point at the moment t (t can be non-integer) is calculated as x_i + t ⋅ v_i.
Consider two points i and j. Let d(i, j) be the minimum possible distance between these two points over any possible moments of time (even non-integer). It means that if two points i and j coincide at some moment, the value d(i, j) will be 0.
Your task is to calculate the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Input
The first line of the input contains one integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the number of points.
The second line of the input contains n integers x_1, x_2, ..., x_n (1 ≤ x_i ≤ 10^8), where x_i is the initial coordinate of the i-th point. It is guaranteed that all x_i are distinct.
The third line of the input contains n integers v_1, v_2, ..., v_n (-10^8 ≤ v_i ≤ 10^8), where v_i is the speed of the i-th point.
Output
Print one integer — the value ∑_{1 ≤ i < j ≤ n} d(i, j) (the sum of minimum distances over all pairs of points).
Examples
Input
3
1 3 2
-100 2 3
Output
3
Input
5
2 1 4 3 5
2 2 2 3 4
Output
19
Input
2
2 1
-3 0
Output
0
Submitted Solution:
```
import sys
input=sys.stdin.readline
def getsum(BITTree,i):
s = 0
while i > 0:
s += BITTree[i]
i -= i & (-i)
return(s)
def updatebit(BITTree , n , i ,v):
while i <= n:
BITTree[i] += v
i += i & (-i)
n=int(input())
x=[int(i) for i in input().split() if i!='\n']
v=[int(i) for i in input().split() if i!='\n']
for i in range(n):
v[i]=[v[i],i]
v.sort()
pos=dict()
store,prev=1,v[0][0]
for i in range(n):
if i>0:
if prev==v[i][0]:
pos[x[v[i][1]]]=store
else:
store+=1
pos[x[v[i][1]]]=store
else:
pos[x[v[i][1]]]=store
#print(pos)
sort=sorted(pos.keys())
bit=[0]*(n+1)
ind=[0]*(n+1)
ans,count,diff=0,0,0
length=max(sort)
total=0
for i in range(len(sort)):
count=getsum(bit,pos[sort[i]])
diff=getsum(ind,pos[sort[i]])
ans+=count*sort[i]-diff
updatebit(bit,len(bit)-1,pos[sort[i]],1)
updatebit(ind,len(ind)-1,pos[sort[i]],sort[i])
print(int(ans))
``` | instruction | 0 | 85,829 | 3 | 171,658 |
No | output | 1 | 85,829 | 3 | 171,659 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
import math
import sys
sys.setrecursionlimit(1000)
n, x, y = map(int, input().split())
print(max(0, math.ceil(n * y / 100) - x))
``` | instruction | 0 | 85,983 | 3 | 171,966 |
Yes | output | 1 | 85,983 | 3 | 171,967 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
import math
from bisect import bisect_left,bisect,bisect_right
from itertools import accumulate
def index(a, x):
'Locate the leftmost value exactly equal to x'
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
raise ValueError
def find_lt(a, x):
'Find rightmost value less than x'
i = bisect_left(a, x)
if i:
return a[i-1]
raise ValueError
def find_le(a, x):
'Find rightmost value less than or equal to x'
i = bisect_right(a, x)
if i:
return a[i-1]
raise ValueError
def find_gt(a, x):
'Find leftmost value greater than x'
i = bisect_right(a, x)
if i != len(a):
return a[i]
raise ValueError
def find_ge(a, x):
'Find leftmost item greater than or equal to x'
i = bisect_left(a, x)
if i != len(a):
return a[i]
raise ValueError
st=''
def func(n,x,y):
return max(0,math.ceil(y*n/100)-x)
for _ in range(1):#int(input())):
n,a,b=map(int,input().split())
#n = int(input())
#inp=input().split()
#s=input()
#l1=[]
#l1=list(map(int,input().split()))
#l1=list(accumulate(list(map(int,input().split()))))
#q=int(input())
#l2 = list(map(int, input().split()))
#l1=input().split()
#l2=input().split()
#func(n,m)
st+=str(int(func(n,a,b)))+'\n'
print(st)
``` | instruction | 0 | 85,984 | 3 | 171,968 |
Yes | output | 1 | 85,984 | 3 | 171,969 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
n,x,y=input().split()
n=int(n)
x=int(x)
y=int(y)
import math
needed=math.ceil((n*y)/100)
if(needed>=x):
print(needed-x)
else:
print(0)
``` | instruction | 0 | 85,985 | 3 | 171,970 |
Yes | output | 1 | 85,985 | 3 | 171,971 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
import math
n,x,y=map(int,input().split())
k=(y/100)*n
k=math.ceil(k)
print(abs(k-x))
``` | instruction | 0 | 85,986 | 3 | 171,972 |
No | output | 1 | 85,986 | 3 | 171,973 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
n, x, y = map(int, input().split())
people = n * y / 100
if not people.is_integer():
people = int(people) + 1
else:
people = int(people)
print(people - x)
``` | instruction | 0 | 85,987 | 3 | 171,974 |
No | output | 1 | 85,987 | 3 | 171,975 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
a, b, c = map(int, input().split())
print(a,b,c)
``` | instruction | 0 | 85,988 | 3 | 171,976 |
No | output | 1 | 85,988 | 3 | 171,977 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Some country is populated by wizards. They want to organize a demonstration.
There are n people living in the city, x of them are the wizards who will surely go to the demonstration. Other city people (n - x people) do not support the wizards and aren't going to go to the demonstration. We know that the city administration will react only to the demonstration involving at least y percent of the city people. Having considered the matter, the wizards decided to create clone puppets which can substitute the city people on the demonstration.
So all in all, the demonstration will involve only the wizards and their puppets. The city administration cannot tell the difference between a puppet and a person, so, as they calculate the percentage, the administration will consider the city to be consisting of only n people and not containing any clone puppets.
Help the wizards and find the minimum number of clones to create to that the demonstration had no less than y percent of the city people.
Input
The first line contains three space-separated integers, n, x, y (1 ≤ n, x, y ≤ 104, x ≤ n) — the number of citizens in the city, the number of wizards and the percentage the administration needs, correspondingly.
Please note that y can exceed 100 percent, that is, the administration wants to see on a demonstration more people that actually live in the city ( > n).
Output
Print a single integer — the answer to the problem, the minimum number of clones to create, so that the demonstration involved no less than y percent of n (the real total city population).
Examples
Input
10 1 14
Output
1
Input
20 10 50
Output
0
Input
1000 352 146
Output
1108
Note
In the first sample it is necessary that at least 14% of 10 people came to the demonstration. As the number of people should be integer, then at least two people should come. There is only one wizard living in the city and he is going to come. That isn't enough, so he needs to create one clone.
In the second sample 10 people should come to the demonstration. The city has 10 wizards. They will all come to the demonstration, so nobody has to create any clones.
Submitted Solution:
```
import math
def solve():
words = input().split()
people = int(words[0])
wizards = int(words[1])
percent = int(words[2])/100
current = wizards/people
per = 1/people
if current>=percent:
print(0)
return
count = 0
while current<percent:
count +=1
current = current+per
print(count)
# for _ in range(int(input())):
solve()
``` | instruction | 0 | 85,989 | 3 | 171,978 |
No | output | 1 | 85,989 | 3 | 171,979 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
__author__ = 'Darren'
def solve():
import sys
stdin = sys.stdin if True else open('data')
def alloc(n):
nonlocal m, id_counter, memory, block_pointer
space = 0
for i in range(m):
if memory[i] == 0:
space += 1
if space == n:
block_pointer.append(i - n + 1)
for j in range(i, i-n, -1):
memory[j] = id_counter
return True
else:
space = 0
return False
def erase(id):
nonlocal t, m, memory, block_pointer
if id <= 0 or id >= len(block_pointer) or block_pointer[id] < 0:
return False
i = block_pointer[id]
while i < m and memory[i] == id:
memory[i] = 0
i += 1
block_pointer[id] = -1
return True
def defragment():
nonlocal m, memory, block_pointer
i = 0
for j in range(m):
if memory[j] > 0:
if j > 0 and memory[j] != memory[j-1]:
block_pointer[memory[j]] = i
memory[i] = memory[j]
i += 1
while i < m:
memory[i] = 0
i += 1
t, m = map(int, next(stdin).split())
memory = [0 for i in range(m)]
block_pointer = [-1]
id_counter = 1
for command in stdin:
command = command.strip()
if command == 'defragment':
defragment()
else:
part1, part2 = command.split()
part2 = int(part2)
if part1 == 'alloc':
if alloc(part2):
print(id_counter)
id_counter += 1
else:
print('NULL')
elif part1 == 'erase':
if not erase(part2):
print('ILLEGAL_ERASE_ARGUMENT')
else:
pass
else:
pass
if __name__ == '__main__':
solve()
``` | instruction | 0 | 86,201 | 3 | 172,402 |
Yes | output | 1 | 86,201 | 3 | 172,403 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
t, m = [int(i) for i in input().split()]
a = []
k = 0
for i in range(t):
f = True
op = input()
if op[:5] == "alloc":
j, b = op.split()
b = int(b)
s = 0
for j in range(len(a)):
if a[j][1] - s >= b:
k += 1
a.insert(j, (k, s, b))
print(k)
f = False
break
else:
s = a[j][1] + a[j][2]
if f:
if m - s >= b:
k += 1
a.append((k, s, b))
print(k)
continue
else:
print("NULL")
elif op[:5] == "erase":
j, b = op.split()
b = int(b)
for j in a:
if j[0] == b:
a.remove(j)
f = False
break
if f:
print("ILLEGAL_ERASE_ARGUMENT")
else:
s = 0
for j in range(len(a)):
a[j] = (a[j][0], s, a[j][2])
s += a[j][2]
``` | instruction | 0 | 86,202 | 3 | 172,404 |
Yes | output | 1 | 86,202 | 3 | 172,405 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
def CF_7B():
t,m=list(map(int,input().split()))
operation=[]
for i in range(0,t):
line=input().split()
if len(line)==2:
line[1]=int(line[1])
operation.append(line)
memory=[None]*m
id=1
for i in range(0,t):
if operation[i][0]=='alloc':
memory,id=alloc(memory,operation[i][1],id)
if operation[i][0]=='erase':
memory=erase(memory,operation[i][1])[:]
if operation[i][0]=='defragment':
memory=defragment(memory)[:]
return
def alloc(mem,n,id):
length=0
for i in range(0,len(mem)):
if mem[i]!=None:
length=0
continue
else:
length+=1
if length==n:
break
if length<n:
print('NULL')
return [mem,id]
else:
for j in range(i-n+1,i+1):
mem[j]=id
print(id)
id+=1
return [mem,id]
def erase(mem,x):
if not x in mem:
print('ILLEGAL_ERASE_ARGUMENT')
else:
for i in range(0,len(mem)):
if mem[i]==x:
mem[i]=None
return mem
def defragment(mem):
res=[]
for i in range(0,len(mem)):
if mem[i]!=None:
res.append(mem[i])
res.extend([None]*mem.count(None))
return res
CF_7B()
``` | instruction | 0 | 86,203 | 3 | 172,406 |
Yes | output | 1 | 86,203 | 3 | 172,407 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
t, n = map(int, input().split())
id = 1
arr = []
for i in range(0, t):
s = input()
if s == 'defragment':
idx = 0
prev = 0
while idx < len(arr):
if arr[idx][0] == -1000:
arr.pop(idx)
else:
size = arr[idx][2] - arr[idx][1]
arr[idx] = [arr[idx][0], prev, prev + size]
prev = prev + size
idx += 1
# print(arr)
# print(idx)
else:
op = s.split()[0]
val = int(s.split()[1])
if op == 'alloc':
start = 0
idx = 0
while idx < len(arr):
next = arr[idx]
if next[1] == -1000:
idx += 1
elif next[1] - start >= val:
break
else:
start = next[2]
idx += 1
if n - start >= val:
arr.insert(idx, [id, start, start + val])
print(id)
# print(arr[idx])
id += 1
else:
print('NULL')
else:
isIllegal = False
# print('earse', val)
for rg in arr:
if rg[0] == val:
rg[0] = rg[1] = rg[2] = -1000
isIllegal = True
break
if not isIllegal:
print('ILLEGAL_ERASE_ARGUMENT')
``` | instruction | 0 | 86,204 | 3 | 172,408 |
Yes | output | 1 | 86,204 | 3 | 172,409 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
class CodeforcesTask7BSolution:
def __init__(self):
self.result = ''
self.t_m = []
self.commands = []
def read_input(self):
self.t_m = [int(x) for x in input().split(" ")]
for x in range(self.t_m[0]):
self.commands.append(input().split(" "))
def process_task(self):
block = 1
memory = [0] * self.t_m[1]
results = []
blocks = []
try:
for cmd in self.commands:
if cmd[0] == "alloc":
if str([0] * int(cmd[1])).replace("[", "").replace("]", "") in str(memory).replace("[", "").replace("]", ""):
preal = memory[::]
results.append(block)
blocks.append(block)
y = (str(memory) + ", ").replace("[", "").replace("]", "").find(str([0] * int(cmd[1])).replace("[", "").replace("]", "") + ", ") // 3
for x in range(int(cmd[1])):
memory[y + x] = block
block += 1
else:
results.append("NULL")
elif cmd[0] == "erase":
if int(cmd[1]) in blocks:
rem = int(cmd[1])
memory = [x if x != rem else 0 for x in memory]
blocks.remove(rem)
else:
results.append("ILLEGAL_ERASE_ARGUMENT")
else:
new_mem = []
for m in memory:
if m:
new_mem.append(m)
new_mem += [0] * (self.t_m[1] - len(new_mem))
memory = new_mem
except Exception as e:
print(e, preal, cmd, y)
print(memory)
self.result = "\n".join([str(x) for x in results])
def get_result(self):
return self.result
if __name__ == "__main__":
Solution = CodeforcesTask7BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())
``` | instruction | 0 | 86,205 | 3 | 172,410 |
No | output | 1 | 86,205 | 3 | 172,411 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
def main():
t, m = map(int, input().split())#t:Cantidad de ordenes dadas, m:Tamaño de memoria disponible en bytes
mem = [0]*m
iden = 1 #Identificador de los bloques
ans = [] #Respuestas
for _ in range(t):
orders = list(input().split())
order = orders[0] #Órden
if len(orders) == 2: n = orders[1]; n = int(n) #Número de la orden
if order == "alloc":
for i in range(m - n + 1):
if mem[i : i+n] == [0]*n:
mem[i : i+n] = [iden]*n
ans.append(iden)
iden += 1
break
else:
ans.append("NULL")
elif order == "erase":
if n in mem:
mem = [0 if i == n else i for i in mem]
else: ans.append("ILLEGAL_ERASE_ARGUMENT")
elif order == "defragment":
for _ in range(m):
if 0 in mem: mem.remove(0)
mem = mem + [0]*(m-int(len(mem)))
for i in ans: print(i)
if __name__ == "__main__":
main()
``` | instruction | 0 | 86,206 | 3 | 172,412 |
No | output | 1 | 86,206 | 3 | 172,413 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
"""
Codeforces
7B - Memory Manager
http://codeforces.com/contest/7/problem/B
Héctor González Belver
../07/2018
"""
import sys
def main():
t, m = map(int, sys.stdin.readline().strip().split())
memory = [0] * m
block_number = 0
def allocate(bytes):
nonlocal block_number
hi = -1
allocated = False
while not allocated:
try:
lo = memory.index(0, hi+1)
except ValueError:
break
hi = lo + bytes - 1
if hi >= m:
break
if not any(memory[lo:hi+1]):
block_number += 1
for i in range(bytes):
memory[lo+i] = block_number
allocated = True
if not allocated:
sys.stdout.write('NULL' + '\n')
else:
sys.stdout.write(str(block_number) + '\n')
def erase(block):
try:
idx = memory.index(block)
except ValueError:
sys.stdout.write('ILLEGAL_ERASE_ARGUMENT' + '\n')
else:
while idx < m and memory[idx] == block:
memory[idx] = 0
idx += 1
def defragmentate():
nonlocal memory
memory = [byte for byte in memory if byte]
memory += [0] * (m - len(memory))
for _ in range(t):
operation = sys.stdin.readline().strip().split()
if operation[0] == 'alloc':
allocate(int(operation[1]))
elif operation[0] == 'erase':
erase(int(operation[1]))
elif operation[0] == 'defragment':
defragmentate()
if __name__ == '__main__':
main()
``` | instruction | 0 | 86,207 | 3 | 172,414 |
No | output | 1 | 86,207 | 3 | 172,415 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is little time left before the release of the first national operating system BerlOS. Some of its components are not finished yet — the memory manager is among them. According to the developers' plan, in the first release the memory manager will be very simple and rectilinear. It will support three operations:
* alloc n — to allocate n bytes of the memory and return the allocated block's identifier x;
* erase x — to erase the block with the identifier x;
* defragment — to defragment the free memory, bringing all the blocks as close to the beginning of the memory as possible and preserving their respective order;
The memory model in this case is very simple. It is a sequence of m bytes, numbered for convenience from the first to the m-th.
The first operation alloc n takes as the only parameter the size of the memory block that is to be allocated. While processing this operation, a free block of n successive bytes is being allocated in the memory. If the amount of such blocks is more than one, the block closest to the beginning of the memory (i.e. to the first byte) is prefered. All these bytes are marked as not free, and the memory manager returns a 32-bit integer numerical token that is the identifier of this block. If it is impossible to allocate a free block of this size, the function returns NULL.
The second operation erase x takes as its parameter the identifier of some block. This operation frees the system memory, marking the bytes of this block as free for further use. In the case when this identifier does not point to the previously allocated block, which has not been erased yet, the function returns ILLEGAL_ERASE_ARGUMENT.
The last operation defragment does not have any arguments and simply brings the occupied memory sections closer to the beginning of the memory without changing their respective order.
In the current implementation you are to use successive integers, starting with 1, as identifiers. Each successful alloc operation procession should return following number. Unsuccessful alloc operations do not affect numeration.
You are to write the implementation of the memory manager. You should output the returned value for each alloc command. You should also output ILLEGAL_ERASE_ARGUMENT for all the failed erase commands.
Input
The first line of the input data contains two positive integers t and m (1 ≤ t ≤ 100;1 ≤ m ≤ 100), where t — the amount of operations given to the memory manager for processing, and m — the available memory size in bytes. Then there follow t lines where the operations themselves are given. The first operation is alloc n (1 ≤ n ≤ 100), where n is an integer. The second one is erase x, where x is an arbitrary 32-bit integer numerical token. The third operation is defragment.
Output
Output the sequence of lines. Each line should contain either the result of alloc operation procession , or ILLEGAL_ERASE_ARGUMENT as a result of failed erase operation procession. Output lines should go in the same order in which the operations are processed. Successful procession of alloc operation should return integers, starting with 1, as the identifiers of the allocated blocks.
Examples
Input
6 10
alloc 5
alloc 3
erase 1
alloc 6
defragment
alloc 6
Output
1
2
NULL
3
Submitted Solution:
```
t,m=input().split()
t,m=int(t),int(m)
d={i:-1 for i in range(t+1)}
s={i:-1 for i in range(t+1)}
b=[0]*m
l=[]
r=1
for i in range(t):
c=input().split()
if c[0]=='alloc':
k=int(c[1])
z=0
for i in range(m):
if b[i]:z=0
else:
z+=1
if z==k:break
else:
print('NULL')
continue
print(r)
d[r]=i-k+1
s[r]=k
for j in range(len(l)):
if d[l[j]]>d[r]:
l=l[:j]+[r]+l[j:]
break
else:
l.append(r)
for j in range(i-k+1,i+1):b[j]=1
r+=1
elif c[0]=='erase':
k=int(c[1])
if 0<=k<=t and d[k]+1:
l.remove(k)
for i in range(d[k],d[k]+s[k]):b[i]=0
d[k]=-1
else:
print('ILLEGAL_ERASE_ARGUMENT')
else:
b=[1]*sum(b)+[0]*(m-sum(b))
e={i:-1 for i in range(t+1)}
n=0
for i in l:
e[i]=n
n+=s[i]
d=e
print(c,b,d,s,sep='\n',end='\n\n')
``` | instruction | 0 | 86,208 | 3 | 172,416 |
No | output | 1 | 86,208 | 3 | 172,417 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Igor is a post-graduate student of chemistry faculty in Berland State University (BerSU). He needs to conduct a complicated experiment to write his thesis, but laboratory of BerSU doesn't contain all the materials required for this experiment.
Fortunately, chemical laws allow material transformations (yes, chemistry in Berland differs from ours). But the rules of transformation are a bit strange.
Berland chemists are aware of n materials, numbered in the order they were discovered. Each material can be transformed into some other material (or vice versa). Formally, for each i (2 ≤ i ≤ n) there exist two numbers xi and ki that denote a possible transformation: ki kilograms of material xi can be transformed into 1 kilogram of material i, and 1 kilogram of material i can be transformed into 1 kilogram of material xi. Chemical processing equipment in BerSU allows only such transformation that the amount of resulting material is always an integer number of kilograms.
For each i (1 ≤ i ≤ n) Igor knows that the experiment requires ai kilograms of material i, and the laboratory contains bi kilograms of this material. Is it possible to conduct an experiment after transforming some materials (or none)?
Input
The first line contains one integer number n (1 ≤ n ≤ 105) — the number of materials discovered by Berland chemists.
The second line contains n integer numbers b1, b2... bn (1 ≤ bi ≤ 1012) — supplies of BerSU laboratory.
The third line contains n integer numbers a1, a2... an (1 ≤ ai ≤ 1012) — the amounts required for the experiment.
Then n - 1 lines follow. j-th of them contains two numbers xj + 1 and kj + 1 that denote transformation of (j + 1)-th material (1 ≤ xj + 1 ≤ j, 1 ≤ kj + 1 ≤ 109).
Output
Print YES if it is possible to conduct an experiment. Otherwise print NO.
Examples
Input
3
1 2 3
3 2 1
1 1
1 1
Output
YES
Input
3
3 2 1
1 2 3
1 1
1 2
Output
NO | instruction | 0 | 86,212 | 3 | 172,424 |
Tags: dfs and similar, greedy, trees
Correct Solution:
```
import sys
# @profile
def main():
f = sys.stdin
# f = open('input.txt', 'r')
# fo = open('log.txt', 'w')
n = int(f.readline())
# b = []
# for i in range(n):
# b.append()
b = list(map(int, f.readline().strip().split(' ')))
a = list(map(int, f.readline().strip().split(' ')))
# return
b = [b[i] - a[i] for i in range(n)]
c = [[0, 0]]
for i in range(n - 1):
line = f.readline().strip().split(' ')
c.append([int(line[0]), int(line[1])])
# print(c)
for i in range(n - 1, 0, -1):
# print(i)
fa = c[i][0] - 1
if b[i] >= 0:
b[fa] += b[i]
else:
b[fa] += b[i] * c[i][1]
if b[fa] < -1e17:
print('NO')
return 0
# for x in b:
# fo.write(str(x) + '\n')
if b[0] >= 0:
print('YES')
else:
print('NO')
main()
``` | output | 1 | 86,212 | 3 | 172,425 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Igor is a post-graduate student of chemistry faculty in Berland State University (BerSU). He needs to conduct a complicated experiment to write his thesis, but laboratory of BerSU doesn't contain all the materials required for this experiment.
Fortunately, chemical laws allow material transformations (yes, chemistry in Berland differs from ours). But the rules of transformation are a bit strange.
Berland chemists are aware of n materials, numbered in the order they were discovered. Each material can be transformed into some other material (or vice versa). Formally, for each i (2 ≤ i ≤ n) there exist two numbers xi and ki that denote a possible transformation: ki kilograms of material xi can be transformed into 1 kilogram of material i, and 1 kilogram of material i can be transformed into 1 kilogram of material xi. Chemical processing equipment in BerSU allows only such transformation that the amount of resulting material is always an integer number of kilograms.
For each i (1 ≤ i ≤ n) Igor knows that the experiment requires ai kilograms of material i, and the laboratory contains bi kilograms of this material. Is it possible to conduct an experiment after transforming some materials (or none)?
Input
The first line contains one integer number n (1 ≤ n ≤ 105) — the number of materials discovered by Berland chemists.
The second line contains n integer numbers b1, b2... bn (1 ≤ bi ≤ 1012) — supplies of BerSU laboratory.
The third line contains n integer numbers a1, a2... an (1 ≤ ai ≤ 1012) — the amounts required for the experiment.
Then n - 1 lines follow. j-th of them contains two numbers xj + 1 and kj + 1 that denote transformation of (j + 1)-th material (1 ≤ xj + 1 ≤ j, 1 ≤ kj + 1 ≤ 109).
Output
Print YES if it is possible to conduct an experiment. Otherwise print NO.
Examples
Input
3
1 2 3
3 2 1
1 1
1 1
Output
YES
Input
3
3 2 1
1 2 3
1 1
1 2
Output
NO | instruction | 0 | 86,213 | 3 | 172,426 |
Tags: dfs and similar, greedy, trees
Correct Solution:
```
n=int(input())
a=[int(x) for x in input().split()]
b=[int(x) for x in input().split()]
pred=[0 for i in range(n)]
weight=[0 for i in range(n)]
for i in range(1,n):
x,y = [int(z) for z in input().split()]
pred[i]=x-1
weight[i]=y
tot=sum(a)
for i in range(n-1,-1,-1):
#print(i)
y=a[i]-b[i]
if y>0:
a[pred[i]]+=y
else:
b[pred[i]]-=weight[i]*y
if b[i]>tot:
print("NO")
exit(0)
print("YES" if a[0]>=b[0] else "NO")
``` | output | 1 | 86,213 | 3 | 172,427 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Igor is a post-graduate student of chemistry faculty in Berland State University (BerSU). He needs to conduct a complicated experiment to write his thesis, but laboratory of BerSU doesn't contain all the materials required for this experiment.
Fortunately, chemical laws allow material transformations (yes, chemistry in Berland differs from ours). But the rules of transformation are a bit strange.
Berland chemists are aware of n materials, numbered in the order they were discovered. Each material can be transformed into some other material (or vice versa). Formally, for each i (2 ≤ i ≤ n) there exist two numbers xi and ki that denote a possible transformation: ki kilograms of material xi can be transformed into 1 kilogram of material i, and 1 kilogram of material i can be transformed into 1 kilogram of material xi. Chemical processing equipment in BerSU allows only such transformation that the amount of resulting material is always an integer number of kilograms.
For each i (1 ≤ i ≤ n) Igor knows that the experiment requires ai kilograms of material i, and the laboratory contains bi kilograms of this material. Is it possible to conduct an experiment after transforming some materials (or none)?
Input
The first line contains one integer number n (1 ≤ n ≤ 105) — the number of materials discovered by Berland chemists.
The second line contains n integer numbers b1, b2... bn (1 ≤ bi ≤ 1012) — supplies of BerSU laboratory.
The third line contains n integer numbers a1, a2... an (1 ≤ ai ≤ 1012) — the amounts required for the experiment.
Then n - 1 lines follow. j-th of them contains two numbers xj + 1 and kj + 1 that denote transformation of (j + 1)-th material (1 ≤ xj + 1 ≤ j, 1 ≤ kj + 1 ≤ 109).
Output
Print YES if it is possible to conduct an experiment. Otherwise print NO.
Examples
Input
3
1 2 3
3 2 1
1 1
1 1
Output
YES
Input
3
3 2 1
1 2 3
1 1
1 2
Output
NO
Submitted Solution:
```
rd = lambda: list(map(int, input().split()))
n = rd()[0]
b = [0] + rd()
a = [0] + rd()
x = [0 for _ in range(n + 1)]
k = [0 for _ in range(n + 1)]
for i in range(2, n + 1):
x[i], k[i] = rd()
for i in range(n, 0, -1):
if b[i] < a[i]:
if i == 1 or k[i] * (a[i] - b[i]) > b[x[i]]:
print("NO")
exit(0)
b[x[i]] -= k[i] * (a[i] - b[i])
b[i] = a[i]
b[x[i]] = b[x[i]] + b[i] - a[i]
print("YES")
``` | instruction | 0 | 86,214 | 3 | 172,428 |
No | output | 1 | 86,214 | 3 | 172,429 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,401 | 3 | 172,802 |
"Correct Solution:
```
import bisect
def inpl(): return [int(i) for i in input().split()]
X = int(input())
K = int(input())
r = [0] + inpl()
stu = [()]*(K+1)
stu[0] = (X, 0, 0)
for i, v in enumerate(r[1:], 1):
s, t, u = stu[i-1]
if i%2:
rs = r[i-1] - r[i]
ap = - rs - t
if ap >= s:
stu[i] = 0, 0, 0
elif ap >= u:
stu[i] = s, t+rs, ap
else:
stu[i] = s, t+rs, u
else:
rs = r[i] - r[i-1]
ap = X - rs - t
if ap >= s:
stu[i] = s, t+rs, u
elif ap >= u:
stu[i] = ap, t+rs, u
else:
stu[i] = X, 0, X
Q = int(input())
for _ in range(Q):
ti, a = inpl()
x = bisect.bisect_right(r, ti)
ti -= r[x-1]
s, t, u = stu[x-1]
if a >= s:
R = s + t
elif a >= u:
R = a + t
else:
R = u + t
if x % 2:
print(max(0, R - ti))
else:
print(min(X, R + ti))
``` | output | 1 | 86,401 | 3 | 172,803 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,402 | 3 | 172,804 |
"Correct Solution:
```
def calc_ans(x):
if x < 0:
return 0
elif x < X:
return x
else:
return X
if __name__ == '__main__':
# 砂の合計量
X = int(input())
# ひっくり返す回数
K = int(input())
# ひっくり返す秒数
r = list(map(int, input().split()))
# クエリの個数
Q = int(input())
# r の制御のための変数
j = 0
sign = -1
s = 0
e = X
y = 0
sand_quantity = [r[0]]
for i in range(1, K):
sand_quantity.append(r[i] - r[i - 1])
chasm_time = 0
for i in range(Q):
# t:時刻 a:初期に A に入っている砂の量
t, a = list(map(int, input().split()))
while j < K and r[j] < t:
y += sign * sand_quantity[j]
# sについて更新
if y < 0:
s += -y
if e < s:
s = e
y = 0
# eについて更新
if X < y + e - s:
tmp_diff = (y + e - s) - X
e -= tmp_diff
if e < s:
e = s
if X < y:
y = X
chasm_time = r[j]
j += 1
sign *= -1
tmp_time = t - chasm_time
if a < s:
ret = y
elif a < e:
ret = y + a - s
else:
ret = y + e - s
ret += tmp_time * sign
print(calc_ans(ret))
# print("s:" + str(s) + " e:" + str(e) + " y:" + str(y) + " a:" + str(a) + " ret:" + str(ret))
``` | output | 1 | 86,402 | 3 | 172,805 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,403 | 3 | 172,806 |
"Correct Solution:
```
def main():
import sys
from operator import itemgetter
input = sys.stdin.readline
X = int(input())
K = int(input())
R = list(map(int, input().split()))
Q = []
for r in R:
Q.append((r, -1))
q = int(input())
for _ in range(q):
t, a = map(int, input().split())
Q.append((t, a))
Q.sort(key=itemgetter(0))
#print(Q)
prev = 0
m = 0
M = X
flg = -1
R_cs = 0
for t, a in Q:
if a < 0:
r = t - prev
R_cs -= r * flg
if flg == -1:
m = max(0, m-r)
M = max(0, M-r)
flg = 1
else:
m = min(X, m+r)
M = min(X, M+r)
flg = -1
prev = t
else:
if m == M:
if flg == 1:
print(min(X, m + t - prev))
else:
print(max(0, m - t + prev))
else:
am = m + R_cs
aM = M + R_cs
#print('am', am, 'aM', aM, m, M)
if a <= am:
if flg == 1:
print(min(X, m + t - prev))
else:
print(max(0, m - t + prev))
elif a >= aM:
if flg == 1:
print(min(X, M + t - prev))
else:
print(max(0, M - t + prev))
else:
if flg == 1:
print(min(X, m + (a - am) + t - prev))
else:
print(max(0, m + (a - am) - t + prev))
if __name__ == '__main__':
main()
``` | output | 1 | 86,403 | 3 | 172,807 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,404 | 3 | 172,808 |
"Correct Solution:
```
X = int(input())
K = int(input())
r_lst = [int(_) for _ in input().split()]
Q = int(input())
t_lst, a_lst = [], []
for i in range(Q):
buf = input().split()
t_lst.append(int(buf[0]))
a_lst.append(int(buf[1]))
pos_lst = []
for i, r in enumerate(r_lst):
direc = "+" if i%2==0 else "-"
pos_lst.append((r, direc))
for i, t in enumerate(t_lst):
pos_lst.append((t, i))
pos_lst = sorted(pos_lst, key=lambda tup: tup[0])
left, right = 0, X
val = [0, 0, X]
direc = "-"
prv = 0
for pos in pos_lst:
# print(left, right)
# print(val)
# print(pos)
# print()
elapsed = pos[0] - prv
prv = pos[0]
if direc == "+":
val[0] = min(X, val[0] + elapsed)
val[1] += elapsed
val[2] = min(X, val[2] + elapsed)
right = min(right, X - val[1])
else:
val[0] = max(0, val[0] - elapsed)
val[1] -= elapsed
val[2] = max(0, val[2] - elapsed)
left = max(left, -(val[1]))
if pos[1] == "+" or pos[1] == "-":
direc = pos[1]
else: #is query
a = a_lst[pos[1]]
if a <= left:
print(val[0])
elif a >= right:
print(val[2])
else:
print( a + val[1])
``` | output | 1 | 86,404 | 3 | 172,809 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,405 | 3 | 172,810 |
"Correct Solution:
```
import sys
input = sys.stdin.readline
"""
X定数だった。両極端な場合が合流する。
[0,L]上定数A、[R,X]上定数B、その間は線形
"""
X = int(input())
K = int(input())
R = [int(x) for x in input().split()]
Q = int(input())
TA = [tuple(int(x) for x in input().split()) for _ in range(Q)]
task = sorted([(r,-1) for r in R] + [(t,a) for t,a in TA])
L = 0
R = X
A = 0
B = X
dx = -1 # 初めは減る方
current = 0
answer = []
for t,a in task:
# とりあえず上限を突破して落とす
A += dx * (t-current)
B += dx * (t-current)
current = t
if a != -1:
# 体積の計算
if a <= L:
x = A
elif a >= R:
x = B
else:
x = A+(B-A)//(R-L)*(a-L)
if x < 0:
x = 0
if x > X:
x = X
answer.append(x)
else:
dx = -dx
if A < B:
if A < 0:
L += (-A)
A = 0
if B > X:
R -= (B-X)
B = X
if A > X:
A = X
B = X
L = 0
R = 0
if B < 0:
A = 0
B = 0
L = 0
R = 0
elif A >= B:
if A > X:
L += (A-X)
A = X
if B < 0:
R -= (-B)
B = 0
if A < 0:
A = 0
B = 0
L = 0
R = 0
if B > X:
A = X
B = X
L = 0
R = 0
if R < L:
R = L
print(*answer,sep='\n')
``` | output | 1 | 86,405 | 3 | 172,811 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,406 | 3 | 172,812 |
"Correct Solution:
```
# F
# input
from bisect import bisect
X = int(input())
K = int(input())
r_list = [0] + list(map(int, input().split()))
Q = int(input())
query_list = [list(map(int, input().split())) for _ in range(Q)]
MmRL_list = []
# M:max, m:min, R:min_a(M), L:max_a(m)
M = X
m = 0
R = X
L = 0
MmRL_list.append([M, m, R, L])
for i in range(K):
M_ = M
m_ = m
R_ = R
L_ = L
lag = r_list[i+1] - r_list[i]
# update
if i % 2 == 0:
if M_ - lag < 0:
M = 0
R = 0
else:
M = M_ - lag
R = R_
if m_ - lag < 0:
m = 0
L = L_ + lag - m_
else:
m = m_ - lag
L = L_
else:
if M_ + lag > X:
M = X
R = R_ - (M_ + lag - X)
else:
M = M_ + lag
R = R_
if m_ + lag > X:
m = X
L = X
else:
m = m_ + lag
L = L_
MmRL_list.append([M, m, R, L])
# print(MmRL_list)
for q in range(Q):
t, a = query_list[q]
j = bisect(r_list, t) - 1
# find status then
M, m, R, L = MmRL_list[j]
if a <= L:
a_ = m
elif a >= R:
a_ = M
else:
a_ = m + (a - L)
t_ = t - r_list[j]
if j % 2 == 0:
res = max(a_ - t_, 0)
else:
res = min(a_ + t_, X)
print(res)
``` | output | 1 | 86,406 | 3 | 172,813 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,407 | 3 | 172,814 |
"Correct Solution:
```
X = int(input())
K = int(input())
rs = list(map(int,input().split()))
Q = int(input())
qs = [tuple(map(int,input().split())) for i in range(Q)]
dx = -1
ri = 0
offset = 0
upper,lower = X,0
prev_r = 0
ans = []
for t,a in qs:
while ri < len(rs) and rs[ri] <= t:
tmp_offset = dx * (rs[ri] - prev_r)
if dx == 1:
upper = min(X, upper + tmp_offset)
lower = min(X, lower + tmp_offset)
else:
upper = max(0, upper + tmp_offset)
lower = max(0, lower + tmp_offset)
offset += tmp_offset
dx *= -1
prev_r = rs[ri]
ri += 1
a = max(lower, min(upper, a+offset))
dt = t - prev_r
a = max(0, min(X, a + dx*dt))
ans.append(a)
print(*ans, sep='\n')
``` | output | 1 | 86,407 | 3 | 172,815 |
Provide a correct Python 3 solution for this coding contest problem.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100 | instruction | 0 | 86,408 | 3 | 172,816 |
"Correct Solution:
```
X = int(input())
K = int(input())
R = list(map(int, input().split()))
Q = int(input())
ami = [0]*(K+1)
ama = [X] + [0]*K
cusummi = [0]*(K+1)
cusumma = [0]*(K+1)
cusum = [0]*(K+1)
pr = 0
for i, r in enumerate(R):
d = pr-r if i%2==0 else r-pr
cusum[i+1] = cusum[i] + d
cusummi[i+1] = min(cusummi[i], cusum[i+1])
cusumma[i+1] = max(cusumma[i], cusum[i+1])
ami[i+1] = min(max(ami[i] + d, 0), X)
ama[i+1] = min(max(ama[i] + d, 0), X)
pr = r
import bisect
for _ in range(Q):
t, a = map(int, input().split())
i = bisect.bisect_right(R, t)
t1 = R[i-1] if i!=0 else 0
t2 = t-t1
d = -t2 if i%2==0 else t2
if ama[i]==ami[i]:
print(min(max(ama[i] + d, 0), X))
continue
ans = a+cusum[i]
if -cusummi[i]>a:
ans += -cusummi[i]-a
if cusumma[i]>(X-a):
ans -= cusumma[i]-(X-a)
print(min(max(ans+d, 0), X))
``` | output | 1 | 86,408 | 3 | 172,817 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
#!/usr/bin/env python3
import bisect
def main():
X = int(input())
K = int(input())
r = list(map(int, input().split()))
Q = int(input())
q_list = []
for i in range(Q):
q_list.append(list(map(int, input().split())))
r = [0] + r
a = [0]
upper_limit = [X]
lower_limit = [0]
x, ux, lx = 0, X, 0
for i in range(1, K + 1):
diff = r[i] - r[i - 1]
if i % 2 == 1:
x -= diff
ux -= diff
ux = max(ux, 0)
lx -= diff
lx = max(lx, 0)
else:
x += diff
ux += diff
ux = min(ux, X)
lx += diff
lx = min(lx, X)
a.append(x)
upper_limit.append(ux)
lower_limit.append(lx)
asc_i = [0]
dsc_i = [1]
x = 0
for i in range(2, K + 1, 2):
if x < a[i]:
x = a[i]
asc_i.append(i)
x = a[1]
for i in range(3, K + 1, 2):
if a[i] < x:
x = a[i]
dsc_i.append(i)
asc_a = [a[i] for i in asc_i]
dsc_a = [-a[i] for i in dsc_i]
for [t, a0] in q_list:
ri = bisect.bisect_right(r, t) - 1
ui = bisect.bisect_left(asc_a, X - a0)
li = bisect.bisect_left(dsc_a, a0)
ai, di = None, None
if ui < len(asc_i):
ai = asc_i[ui]
if ri < ai:
ai = None
if li < len(dsc_i):
di = dsc_i[li]
if ri < di:
di = None
d = 0
if (not ai is None) or (not di is None):
if ai is None:
d = -1
elif di is None:
d = 1
else:
d = 1 if ai < di else -1
x = a0 + a[ri]
if d == 1:
x = upper_limit[ri]
elif d == -1:
x = lower_limit[ri]
x += (t - r[ri]) * (-1 if ri % 2 == 0 else 1)
x = min(max(x, 0), X)
print(x)
if __name__ == '__main__':
main()
``` | instruction | 0 | 86,409 | 3 | 172,818 |
Yes | output | 1 | 86,409 | 3 | 172,819 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
"""
Writer: SPD_9X2
https://atcoder.jp/contests/arc082/tasks/arc082_d
aiが固定ならば、ただクエリをソートしてシミュレーションしながら答えを出せばよい
今回はそうでないので、方法を考える
一度でも砂が落ち切ってしまえば、その後はaiに関わらず、答えは等しくなる
おちきっていない場合、常に砂が移動し続けるので、初期値からの差分が常に等しくなる
よって、落ち切らないaの範囲を保持し、一度も落ち切らない場合の初期からの差分
& 落ち切ってしまった場合のシミュレーション結果を用いて答えればよい
→どのタイミング(区間)で落ち切るかでその後の動きが違くね？？？
→死
→aの区間は高々3つに分けられる
→ aが少なく、a=0と同じに収束する場合、 aが大きく、a=Xと同じに収束する場合。、一度も落ち切らない場合
→そして、a=0,a=Xと同じになる場合は、それぞれaの初期値の区間の両端から侵食していく
→よって、a=0のシミュ、a=Xのシミュ、落ち切らない差分シミュ。その時あるaがどれに属すかの区間
を用いてシミュレーションしながらdp的に処理してあげればよい
あとは実装が面倒そう
"""
from collections import deque
X = int(input())
K = int(input())
r = list(map(int,input().split()))
#番兵
r.append(float("inf"))
r.append(0)
ta = deque([])
Q = int(input())
for i in range(Q):
t,a = map(int,input().split())
ta.append([t,a])
ZA = 0 #初期がa=0の時のシミュ結果
XA = X #初期がXの時
D = 0 #差分計算
Zmax = 0 #aがZmax以下ならZAと等しくなる
Xmin = X #aがXmin以上ならXAと等しくなる
for i in range(K+1):
time = r[i] - r[i-1]
#クエリの処理(r[i]以下に関して)
if i % 2 == 0: #Aが減っていく
while len(ta) > 0 and ta[0][0] <= r[i]:
t,a = ta.popleft()
td = t - r[i-1]
if a <= Zmax:
print (max( 0 , ZA-td ))
elif a >= Xmin:
print (max (0 , XA-td ))
else:
print (max (0 , a+D-td))
D -= time
Zmax = max(Zmax,-1*D)
ZA = max(0,ZA-time)
XA = max(0,XA-time)
else: #Aが増えていく
while len(ta) > 0 and ta[0][0] <= r[i]:
t,a = ta.popleft()
td = t - r[i-1]
if a <= Zmax:
print (min( X , ZA+td ))
elif a >= Xmin:
print (min (X , XA+td ))
else:
print (min (X , a+D+td))
D += time
Xmin = min(Xmin,X-D)
ZA = min(X,ZA+time)
XA = min(X,XA+time)
``` | instruction | 0 | 86,410 | 3 | 172,820 |
Yes | output | 1 | 86,410 | 3 | 172,821 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
x, = map(int,readline().split())
k, = map(int,readline().split())
*r, = map(int,readline().split())
q, = map(int,readline().split())
r.append(1<<30)
INF = 1<<30
ID_M = (-INF,INF,0)
def compose(lst1,lst2):
return (funcval(lst1[0],lst2),funcval(lst1[1],lst2),lst1[2]+lst2[2])
def funcval(x,lst):
a,b,c = lst
if x <= a-c: return a
elif x >= b-c: return b
else: return x+c
#seg = segment_tree_dual(q, compose, funcval, ID_M)
#seg.build([a for a,t,i in ati])
seg = (0,x,0)
tai = []
for i in range(q):
t,a = map(int,readline().split())
tai.append((t,a,i))
tai.sort(key=lambda x:x[0])
idx = 0
ans = [0]*q
t0 = 0
coeff = -1
for i,ri in enumerate(r):
while idx < q and tai[idx][0] < ri:
t,a,j = tai[idx]
v = funcval(a,seg)
ans[j] = min(x,max(v+coeff*(t-t0),0))
idx += 1
seg = compose(seg,(0,x,coeff*(ri-t0)))
t0 = ri
coeff *= -1
#print(seg)
print(*ans,sep="\n")
``` | instruction | 0 | 86,411 | 3 | 172,822 |
Yes | output | 1 | 86,411 | 3 | 172,823 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
X = int(input())
K = int(input())
R = [int(x) for x in reversed(input().split())]
for i in range(0,K-1): R[i] -= R[i+1]
Q = int(input())
aM = X
M = X
am = 0
m = 0
now = 0
sign = -1
timer = R.pop()
def Go(time):
global aM,M,am,m
if sign==1:
if m+time>X:
m = X
M = X
aM = am
elif M+time>X:
m += time
M = X
aM = am + M - m
else:
m += time
M += time
else:
if M-time<0:
m = 0
M = 0
am = aM
elif m-time<0:
m = 0
M -= time
am = aM + m - M
else:
m -= time
M -= time
for i in range(Q):
t,a = [int(x) for x in input().split()]
t -= now
now += t
while t>=timer:
Go(timer)
t -= timer
if R:
timer = R.pop()
else:
timer = float("inf")
sign *= -1
Go(t)
timer -= t
if a<am:
print(m)
elif a>aM:
print(M)
else:
print(m+a-am)
``` | instruction | 0 | 86,412 | 3 | 172,824 |
Yes | output | 1 | 86,412 | 3 | 172,825 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
import sys
input = sys.stdin.readline
"""
X定数だった。両極端な場合が合流する。
[0,L]上定数A、[R,X]上定数B、その間は線形
"""
X = int(input())
K = int(input())
R = [int(x) for x in input().split()]
Q = int(input())
TA = [tuple(int(x) for x in input().split()) for _ in range(Q)]
task = sorted([(r,-1) for r in R] + [(t,a) for t,a in TA])
L = 0
R = X
A = 0
B = X
dx = -1 # 初めは減る方
current = 0
answer = []
for t,a in task:
# とりあえず上限を突破して落とす
A += dx * (t-current)
B += dx * (t-current)
current = t
if a != -1:
# 体積の計算
if a <= L:
x = A
elif a >= R:
x = B
else:
x = A+(B-A)//(R-L)*(a-L)
if x < 0:
x = 0
if x > X:
x = X
answer.append(x)
else:
dx = -dx
if A < B:
if A < 0:
L += (-A)
A = 0
if B > X:
R -= (B-X)
B = X
if A > X:
A = X
B = X
L = 0
R = 0
if B < 0:
A = 0
B = 0
L = 0
R = 0
elif A > B:
if A > X:
L += (A-X)
A = X
if B < 0:
R -= (-B)
B = 0
if A < 0:
A = 0
B = 0
L = 0
R = 0
if B > X:
A = X
B = X
L = 0
R = 0
if R < L:
R = L
print(*answer,sep='\n')
``` | instruction | 0 | 86,413 | 3 | 172,826 |
No | output | 1 | 86,413 | 3 | 172,827 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
def read_data_f(filename='arc082-e.dat'):
try:
LOCAL_FLAG
import codecs
import os
lines = []
file_path = os.path.join(os.path.dirname(__file__), filename)
with codecs.open(file_path, 'r', 'utf-8') as f:
for each in f:
lines.append(each.rstrip("\r\n"))
except NameError:
lines = []
lines.append(input())
lines.append(input())
lines.append(input())
lines.append(input())
Q = int(lines[3])
for i in range(Q):
lines.append(input())
return lines
def F_Sandglass():
#
# 180
# 3
# 60 120 180
# 3
# 30 90
# 61 1
# 180 180
raw_data = read_data_f('arc082-f.dat')
X = int(raw_data[0])
K = int(raw_data[1])
r = list(map(int, raw_data[2].split()))
Q = int(raw_data[3])
a = []
t = []
for i in range(Q):
tt, aa = list(map(int, raw_data[i+4].split()))
a.append(aa)
t.append(tt)
# print(r)
# print(t)
# print(a)
time = 0
i = j = 0
U = X
L = 0
c = 0
isUp = True
time_diff = 0
r.append(2000000000)
t.append(1)
while (i < K+1) and (time < t[Q-1]):
while((time <= t[j] and t[j] < r[i])):
time_diff_temp = t[j] - time
if(isUp):
c_temp = max(c - time_diff_temp, -X)
U_temp = U
L_temp = L
if(L + c_temp) < 0:
L_temp = min(L + time_diff_temp, X)
else:
c_temp = min(c + time_diff_temp, X)
U_temp = U
if(U + c_temp) > X:
U_temp = max(U - time_diff_temp, 0)
L_temp = L
if(a[j] > U_temp):
print(min(U_temp + c_temp, X))
elif(a[j] < L_temp):
print(max(L_temp + c_temp, 0))
else:
print(a[j] + c_temp)
j += 1
time_diff = r[i] - time
if(isUp):
c = max(c - time_diff, -X)
if(L + c) < 0:
L = -c
if(L > U):
U = L
else:
c = min(c + time_diff, X)
if(U + c) > X:
U = X - c
if(L > U):
L = U
time = r[i]
isUp = not isUp
i += 1
# result = remain(X, A[start_time], t[j] - start_time, start_status)
# print(result)
F_Sandglass()
``` | instruction | 0 | 86,414 | 3 | 172,828 |
No | output | 1 | 86,414 | 3 | 172,829 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
if __name__ == '__main__':
# 砂の合計量
X = int(input())
# ひっくり返す回数
K = int(input())
# ひっくり返す秒数
r = list(map(int, input().split()))
# クエリの個数
Q = int(input())
# r の制御のための変数
j = 0
sign = -1
'''
ある時刻を切り取り、横軸を最初のAの砂の量、縦軸をその時の砂の量とする。
s:傾き始め
e:傾き終わり
c:切片
'''
s = 0
e = X
c = 0
# 出入りする砂の量
sand_quantity = [r[0]]
for i in range(1, K):
sand_quantity.append(r[i] - r[i - 1])
chasm_time = 0
for i in range(Q):
# t:時刻 a:初期に A に入っている砂の量
t, a = list(map(int, input().split()))
while j < K and r[j] < t:
c += sign * sand_quantity[j]
c = max(min(X, c), -X)
# sについて更新
if s < -c:
s = -c
if e < s:
s = e
# eについて更新
if X - c < e:
e = X - c
if e < s:
e = s
chasm_time = r[j]
j += 1
sign *= -1
tmp_time = t - chasm_time
if a < s:
print(max(min(s + c + tmp_time * sign, X), 0))
elif a < e:
print(max(min(a + c + tmp_time * sign, X), 0))
else:
print(max(min(e + c + tmp_time * sign, X), 0))
# print("s:" + str(s) + " e:" + str(e) + " c:" + str(c) + " a:" + str(a))
``` | instruction | 0 | 86,415 | 3 | 172,830 |
No | output | 1 | 86,415 | 3 | 172,831 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
We have a sandglass consisting of two bulbs, bulb A and bulb B. These bulbs contain some amount of sand. When we put the sandglass, either bulb A or B lies on top of the other and becomes the upper bulb. The other bulb becomes the lower bulb.
The sand drops from the upper bulb to the lower bulb at a rate of 1 gram per second. When the upper bulb no longer contains any sand, nothing happens.
Initially at time 0, bulb A is the upper bulb and contains a grams of sand; bulb B contains X-a grams of sand (for a total of X grams).
We will turn over the sandglass at time r_1,r_2,..,r_K. Assume that this is an instantaneous action and takes no time. Here, time t refer to the time t seconds after time 0.
You are given Q queries. Each query is in the form of (t_i,a_i). For each query, assume that a=a_i and find the amount of sand that would be contained in bulb A at time t_i.
Constraints
* 1≤X≤10^9
* 1≤K≤10^5
* 1≤r_1<r_2< .. <r_K≤10^9
* 1≤Q≤10^5
* 0≤t_1<t_2< .. <t_Q≤10^9
* 0≤a_i≤X (1≤i≤Q)
* All input values are integers.
Input
The input is given from Standard Input in the following format:
X
K
r_1 r_2 .. r_K
Q
t_1 a_1
t_2 a_2
:
t_Q a_Q
Output
For each query, print the answer in its own line.
Examples
Input
180
3
60 120 180
3
30 90
61 1
180 180
Output
60
1
120
Input
100
1
100000
4
0 100
90 100
100 100
101 100
Output
100
10
0
0
Input
100
5
48 141 231 314 425
7
0 19
50 98
143 30
231 55
342 0
365 100
600 10
Output
19
52
91
10
58
42
100
Submitted Solution:
```
input = __import__('sys').stdin.readline
MIS = lambda: map(int,input().split())
# f(a) = z a <= x1
# a+z-x1 x1 <= a <= x2
# x2+z-x1 x2 <= a
class Sandgraph:
def __init__(_, X):
_.z = _.x1 = 0
_.x2 = X
def __repr__(_):
return f"<{_.z} {_.x1} {_.x2}>"
def add(_, dt):
# Go towards the ceiling
d1 = min(dt, X-(_.x2+_.z-_.x1))
_.z+= d1
dt-= d1
# Reduce the diagonal
d1 = min(dt, _.x2-_.x1)
_.z+= d1
_.x2-= d1
def sub(_, dt):
# Go towards the floor
d1 = min(dt, _.z)
_.z-= d1
dt-= d1
# Reduce the diagonal
d1 = min(dt, _.x2-_.x1)
_.x1+= d1
def __call__(_, a):
if a <= _.x1: return _.z
elif a <= _.x2: return a + _.z - _.x1
else: return _.x2 + _.z - _.x1
X = int(input())
k = int(input())
rev = list(MIS())
Q = int(input())
sand = Sandgraph(X)
last_t = 0
i = 0 # even -, odd +
for QUERY in range(Q):
t, a = MIS()
while i<k and rev[i] <= t:
dt = rev[i] - last_t
if i%2 == 0: sand.sub(dt)
else: sand.add(dt)
last_t = rev[i]
i+= 1
dt = t - last_t
if i%2 == 0: sand.sub(dt)
else: sand.add(dt)
print(sand(a))
last_t = t
``` | instruction | 0 | 86,416 | 3 | 172,832 |
No | output | 1 | 86,416 | 3 | 172,833 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,417 | 3 | 172,834 |
"Correct Solution:
```
N, M = map(int,input().split())
AB = [list(map(int,input().split())) for _ in range(N)]
CD = [list(map(int,input().split())) for _ in range(M)]
for ab in AB:
man = [(abs(ab[0]-CD[i][0]) + abs(ab[1]-CD[i][1])) for i in range(len(CD))]
print(man.index(min(man))+1)
``` | output | 1 | 86,417 | 3 | 172,835 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,418 | 3 | 172,836 |
"Correct Solution:
```
n,m = map(int,input().split())
a = [list(map(int,input().split()))for x in range(n)]
b = [list(map(int,input().split()))for x in range(m)]
for x in range(n):
c = list()
for y in range(m):
c.append(abs(a[x][0]-b[y][0]) + abs(a[x][1]-b[y][1]))
print(c.index(min(c))+1)
``` | output | 1 | 86,418 | 3 | 172,837 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,419 | 3 | 172,838 |
"Correct Solution:
```
N,M=map(int,input().split())
n=[list(map(int,input().split())) for _ in range(N)]
m=[list(map(int,input().split())) for _ in range(M)]
result=[]
for i in range(len(n)):
result=[]
for j in range(len(m)):
result.append(abs(n[i][0]-m[j][0])+abs(n[i][1]-m[j][1]))
print(result.index(min(result))+1)
``` | output | 1 | 86,419 | 3 | 172,839 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,420 | 3 | 172,840 |
"Correct Solution:
```
N, M = map(int, input().split())
p_s = [list(map(int, input().split())) for _ in range(N)]
p_f = [list(map(int, input().split())) for _ in range(M)]
length = []
for s in p_s:
for f in p_f:
length.append(abs(s[0]-f[0]) + abs(s[1]-f[1]))
print(length.index(min(length))+1)
length = []
``` | output | 1 | 86,420 | 3 | 172,841 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,421 | 3 | 172,842 |
"Correct Solution:
```
N,M = list(map(int, input().split()))
s = []
for i in range(N):
s.append(list(map(int, input().split())))
c = []
for j in range(M):
c.append(list(map(int, input().split())))
for t1 in s:
l = list(map(lambda x: abs(t1[0] - x[0]) + abs(t1[1] - x[1]), c))
print(l.index(min(l)) + 1)
``` | output | 1 | 86,421 | 3 | 172,843 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,422 | 3 | 172,844 |
"Correct Solution:
```
n, m = map(int, input().split())
abes = [list(map(int, input().split())) for _ in range(n)]
cdes = [list(map(int, input().split())) for _ in range(m)]
for a, b in abes:
mi = sorted(cdes, key=lambda x : abs(x[0]-a)+abs(x[1]-b))
print(cdes.index(mi[0])+1)
``` | output | 1 | 86,422 | 3 | 172,845 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,423 | 3 | 172,846 |
"Correct Solution:
```
n,m=map(int,input().split())
std = [list(map(int,input().split())) for i in range(n)]
chk = [list(map(int,input().split())) for i in range(m)]
for s in std:
ans=[]
for i in range(m):
ans.append([abs(s[0]-chk[i][0])+abs(s[1]-chk[i][1]),i+1])
ans.sort()
print(ans[0][1])
``` | output | 1 | 86,423 | 3 | 172,847 |
Provide a correct Python 3 solution for this coding contest problem.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1 | instruction | 0 | 86,424 | 3 | 172,848 |
"Correct Solution:
```
N, M = map(int, input().split())
Ss = [tuple(map(int, input().split())) for i in range(N)]
CPs = [tuple(map(int, input().split())) for i in range(M)]
for a, b in Ss:
dist = [abs(a - c) + abs(b - d) for c, d in CPs]
print(dist.index(min(dist)) + 1)
``` | output | 1 | 86,424 | 3 | 172,849 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1
Submitted Solution:
```
#57b
n,m = map(int,input().split())
a=[list(map(int,input().split())) for _ in range(n)]
b=[list(map(int,input().split())) for _ in range(m)]
for i in range(n):
ans=[]
for j in range(m):
ans.append(abs(a[i][0]-b[j][0])+abs(a[i][1]-b[j][1]))
print(ans.index(min(ans))+1)
``` | instruction | 0 | 86,425 | 3 | 172,850 |
Yes | output | 1 | 86,425 | 3 | 172,851 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1
Submitted Solution:
```
N, M = map(int, input().split())
S = [tuple(map(int, input().split())) for _ in range(N)]
C = [tuple(map(int, input().split())) for _ in range(M)]
for i in S:
ans = 0
k = 10 ** 10
for j in range(M):
n = abs(i[0] - C[j][0]) + abs(i[1] - C[j][1])
if k > n:
k = n
ans = j + 1
else:
print(ans)
``` | instruction | 0 | 86,426 | 3 | 172,852 |
Yes | output | 1 | 86,426 | 3 | 172,853 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N students and M checkpoints on the xy-plane.
The coordinates of the i-th student (1 \leq i \leq N) is (a_i,b_i), and the coordinates of the checkpoint numbered j (1 \leq j \leq M) is (c_j,d_j).
When the teacher gives a signal, each student has to go to the nearest checkpoint measured in Manhattan distance.
The Manhattan distance between two points (x_1,y_1) and (x_2,y_2) is |x_1-x_2|+|y_1-y_2|.
Here, |x| denotes the absolute value of x.
If there are multiple nearest checkpoints for a student, he/she will select the checkpoint with the smallest index.
Which checkpoint will each student go to?
Constraints
* 1 \leq N,M \leq 50
* -10^8 \leq a_i,b_i,c_j,d_j \leq 10^8
* All input values are integers.
Input
The input is given from Standard Input in the following format:
N M
a_1 b_1
:
a_N b_N
c_1 d_1
:
c_M d_M
Output
Print N lines.
The i-th line (1 \leq i \leq N) should contain the index of the checkpoint for the i-th student to go.
Examples
Input
2 2
2 0
0 0
-1 0
1 0
Output
2
1
Input
3 4
10 10
-10 -10
3 3
1 2
2 3
3 5
3 5
Output
3
1
2
Input
5 5
-100000000 -100000000
-100000000 100000000
100000000 -100000000
100000000 100000000
0 0
0 0
100000000 100000000
100000000 -100000000
-100000000 100000000
-100000000 -100000000
Output
5
4
3
2
1
Submitted Solution:
```
n,m = map(int, input().split())
stu = [list(map(int, input().split())) for _ in range(n)]
p = [list(map(int, input().split())) for _ in range(m)]
for x, y in stu:
k = []
for c, d in p:
k.append(abs(x-c)+abs(y-d))
print(k.index(min(k))+1)
``` | instruction | 0 | 86,427 | 3 | 172,854 |
Yes | output | 1 | 86,427 | 3 | 172,855 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.