message stringlengths 2 48.6k | message_type stringclasses 2 values | message_id int64 0 1 | conversation_id int64 318 108k | cluster float64 8 8 | __index_level_0__ int64 636 217k |
|---|---|---|---|---|---|
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are N mountains ranging from east to west, and an ocean to the west.
At the top of each mountain, there is an inn. You have decided to choose where to stay from these inns.
The height of the i-th mountain from the west is H_i.
You can certainly see the ocean from the inn at the top of the westmost mountain.
For the inn at the top of the i-th mountain from the west (i = 2, 3, ..., N), you can see the ocean if and only if H_1 \leq H_i, H_2 \leq H_i, ..., and H_{i-1} \leq H_i.
From how many of these N inns can you see the ocean?
Constraints
* All values in input are integers.
* 1 \leq N \leq 20
* 1 \leq H_i \leq 100
Input
Input is given from Standard Input in the following format:
N
H_1 H_2 ... H_N
Output
Print the number of inns from which you can see the ocean.
Examples
Input
4
6 5 6 8
Output
3
Input
5
4 5 3 5 4
Output
3
Input
5
9 5 6 8 4
Output
1
Submitted Solution:
```
n = int(input())
h = list(map(int, input().split()))
ans = 1
for i in range(1,n):
if h[i] >= h[0] and h[i] >= h[i-1]:
ans += 1
print(ans)
``` | instruction | 0 | 46,007 | 8 | 92,014 |
No | output | 1 | 46,007 | 8 | 92,015 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,042 | 8 | 92,084 |
"Correct Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
def range_goal(self,l,r):
res=0
if l==r:
return l
while l.bit_length()==r.bit_length():
n=l.bit_length()-1
res+=1<<n
l-=1<<n
r-=1<<n
if l==0:
return res
return res+(1<<(r.bit_length()-1))
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | output | 1 | 46,042 | 8 | 92,085 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,043 | 8 | 92,086 |
"Correct Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
if not pos&1:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
else:
if not pos&1:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.val[pos-1]
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
if not pos&1:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
else:
if not pos&1:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.val[pos-1]
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | output | 1 | 46,043 | 8 | 92,087 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,044 | 8 | 92,088 |
"Correct Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | output | 1 | 46,044 | 8 | 92,089 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,046 | 8 | 92,092 |
"Correct Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | output | 1 | 46,046 | 8 | 92,093 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,047 | 8 | 92,094 |
"Correct Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
ids=ids[::-1]
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
end=self.range_goal(l+1,r+1)
ids=self.idgetter(pos,end)
for pos in ids:
self.propagate(pos)
gap=(pos&-pos)//2
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
def range_goal(self,l,r):
n=(l^r).bit_length()-1
m=(l&-l).bit_length()-1
if n>m:
return (r>>n)<<n
else:
return l
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | output | 1 | 46,047 | 8 | 92,095 |
Provide a correct Python 3 solution for this coding contest problem.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2 | instruction | 0 | 46,048 | 8 | 92,096 |
"Correct Solution:
```
from operator import itemgetter
from heapq import heappush, heappop
N, M = map(int, input().split())
LR = [list(map(int, input().split())) for _ in range(N)]
LR.sort(key=itemgetter(1))
A = []
ans_left = 0
idx = 1
for _, r in LR:
if r==M+1 or idx==M+1:
break
ans_left += 1
idx = max(idx+1, r+1)
idx_LR = 0
q = []
for i in range(M+1-ans_left, M+1):
while idx_LR<N and LR[idx_LR][1]<=i:
l, _ = LR[idx_LR]
heappush(q, l)
idx_LR += 1
heappop(q)
while idx_LR<N:
l, _ = LR[idx_LR]
q.append(l)
idx_LR += 1
q.sort(reverse=True)
ans_right = 0
idx = M
for l in q:
if l==0 or idx==0 or ans_right+ans_left==M:
break
ans_right += 1
idx = min(l-1, idx-1)
ans = N - ans_left - ans_right
print(ans)
``` | output | 1 | 46,048 | 8 | 92,097 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2
Submitted Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap!=0)
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap!=0)
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos<=maxi:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
stack.append(self.merge[pos-1])
ids.pop()
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos>=mini:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.merge[pos-1])
self.merge[pos-1]=self.merge_func(self.merge[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1])
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | instruction | 0 | 46,050 | 8 | 92,100 |
Yes | output | 1 | 46,050 | 8 | 92,101 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2
Submitted Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
ids=ids[::-1]
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids[1:]:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | instruction | 0 | 46,052 | 8 | 92,104 |
Yes | output | 1 | 46,052 | 8 | 92,105 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2
Submitted Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(bool(gap))
ids=iter(ids[::-1])
pos=next(ids)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(bool(gap))
ids=iter(ids[::-1])
pos=next(ids)
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
while self.parent[pos]!=-1:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
ids=iter(ids[::-1])
pos=next(ids)
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
ids=iter(ids[::-1])
pos=next(ids)
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
for pos in ids:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,merge_func=min,ide_ele=10**18)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | instruction | 0 | 46,053 | 8 | 92,106 |
No | output | 1 | 46,053 | 8 | 92,107 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There are M chairs arranged in a line. The coordinate of the i-th chair (1 ≤ i ≤ M) is i.
N people of the Takahashi clan played too much games, and they are all suffering from backaches. They need to sit in chairs and rest, but they are particular about which chairs they sit in. Specifically, the i-th person wishes to sit in a chair whose coordinate is not greater than L_i, or not less than R_i. Naturally, only one person can sit in the same chair.
It may not be possible for all of them to sit in their favorite chairs, if nothing is done. Aoki, who cares for the health of the people of the Takahashi clan, decides to provide additional chairs so that all of them can sit in chairs at their favorite positions.
Additional chairs can be placed at arbitrary real coordinates. Find the minimum required number of additional chairs.
Constraints
* 1 ≤ N,M ≤ 2 × 10^5
* 0 ≤ L_i < R_i ≤ M + 1(1 ≤ i ≤ N)
* All input values are integers.
Input
Input is given from Standard Input in the following format:
N M
L_1 R_1
:
L_N R_N
Output
Print the minimum required number of additional chairs.
Examples
Input
4 4
0 3
2 3
1 3
3 4
Output
0
Input
7 6
0 7
1 5
3 6
2 7
1 6
2 6
3 7
Output
2
Input
3 1
1 2
1 2
1 2
Output
2
Input
6 6
1 6
1 6
1 5
1 5
2 6
2 6
Output
2
Submitted Solution:
```
from collections import deque
class LazySegtree():
def __init__(self,n,init_val,merge_func,ide_ele):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
self.lazy=[0 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
else:
self.val[v-1]=10**18
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def lower_kth_update(self,nd,k,x):
if k==-1:
return
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos<=maxi:
self.val[pos-1]+=x
self.lazy[pos-gap-1]+=x*(gap&1)
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def upper_kth_update(self,nd,k,x):
if k==-1:
return
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
gap=(pos&-pos)//2
self.propagate(pos)
if pos>=mini:
self.val[pos-1]+=x
self.lazy[pos+gap-1]+=x*(gap&1)
for pos in ids[::-1]:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
def update(self,l,r,x):
pos=1<<(self.n-1)
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
self.val[pos-1]+=x
self.upper_kth_update(pos-gap,pos-1-l-1,x)
self.lower_kth_update(pos+gap,r-pos,x)
break
while self.parent[pos]!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
pos=self.parent[pos]
def lower_kth_merge(self,nd,k,debug=False):
res=self.ide_ele
if k==-1:
return res
maxi=nd-(nd&-nd)+1+k
ids=self.idgetter(nd,maxi)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos<=maxi:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos-gap-1]+self.lazy[pos-gap-1])
return self.merge_func(stack)
def upper_kth_merge(self,nd,k):
res=self.ide_ele
if k==-1:
return res
mini=nd+(nd&-nd)-1-k
ids=self.idgetter(nd,mini)
for pos in ids:
self.propagate(pos)
stack=[self.ide_ele]
for pos in ids[::-1]:
gap=(pos&-pos)//2
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos-gap-1]+self.lazy[pos-gap-1],self.merge[pos+gap-1]+self.lazy[pos+gap-1])
if pos>=mini:
stack.append(self.val[pos-1])
if not pos&1:
stack.append(self.merge[pos+gap-1]+self.lazy[pos+gap-1])
return self.merge_func(stack)
def query(self,l,r):
pos=1<<(self.n-1)
res=self.ide_ele
while True:
gap=(pos&-pos)//2
self.propagate(pos)
if pos-1<l:
pos+=(pos&-pos)//2
elif pos-1>r:
pos-=(pos&-pos)//2
else:
left=self.upper_kth_merge(pos-gap,pos-1-l-1)
right=self.lower_kth_merge(pos+gap,r-pos)
res=self.merge_func(left,right,self.val[pos-1])
return res
def propagate(self,pos):
if self.lazy[pos-1]:
self.val[pos-1]+=self.lazy[pos-1]
self.merge[pos-1]+=self.lazy[pos-1]
if not pos&1:
gap=(pos&-pos)//2
self.lazy[pos-gap-1]+=self.lazy[pos-1]
self.lazy[pos+gap-1]+=self.lazy[pos-1]
self.lazy[pos-1]=0
return
def idgetter(self,start,goal):
res=[]
pos=goal
while pos!=start:
res.append(pos)
pos=self.parent[pos]
res.append(start)
return res[::-1]
import sys
input=sys.stdin.buffer.readline
ide_ele=10**18
def segfunc(*args):
return min(args)
N,M=map(int,input().split())
init=[0 for i in range(M+2)]
for i in range(1,M+1):
init[0]+=1
init[i+1]-=1
for i in range(1,M+1):
init[i]+=init[i-1]
init[-1]=0
LST=LazySegtree((M+2).bit_length(),init,segfunc,ide_ele)
hito=[tuple(map(int,input().split())) for i in range(N)]
hito.sort()
add=M-N
for l,r in hito:
LST.update(0,r,-1)
m=LST.query(l+1,M+1)+l
add=min(m,add)
print(max(-add,0))
``` | instruction | 0 | 46,054 | 8 | 92,108 |
No | output | 1 | 46,054 | 8 | 92,109 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,215 | 8 | 92,430 |
Tags: greedy
Correct Solution:
```
n = int(input())
l = [int(i) for i in input().split()]
cont=0
for i in range(1,n-1):
if(l[i-1]==l[i+1]==1 and l[i]==0):
l[i-1]=0
l[i+1]=0
cont+=1
print(cont)
``` | output | 1 | 46,215 | 8 | 92,431 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,216 | 8 | 92,432 |
Tags: greedy
Correct Solution:
```
n=int(input())
a=list(map(int,input().split()))
count=0
for i in range(1,n-1):
if a[i]==0:
if a[i-1]==1 and a[i+1]==1:
a[i-1]=a[i+1]=0
count+=1
print(count)
``` | output | 1 | 46,216 | 8 | 92,433 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,217 | 8 | 92,434 |
Tags: greedy
Correct Solution:
```
n = input()
n = int(n)
a = list(map(int, input().split()))
bprv = a[0]
prev = a[1]
curr = a[2]
cnt = 0
for i in range(2,len(a)):
curr = a[i]
if (curr == 1 and prev == 0 and bprv == 1):
cnt += 1
a[i] = 0
curr = 0
bprv = prev
prev = curr
print(cnt)
``` | output | 1 | 46,217 | 8 | 92,435 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,218 | 8 | 92,436 |
Tags: greedy
Correct Solution:
```
n=int(input())
x,count = list(map(int, input().split(" "))),0
for i in range(1,n-1):
if x[i]==0:
if x[i+1]==x[i-1]==1:
count+=1
x[i+1]=0
print(count)
``` | output | 1 | 46,218 | 8 | 92,437 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,219 | 8 | 92,438 |
Tags: greedy
Correct Solution:
```
#In the name of GOD!
n = int(input())
a = list(map(int, input().split()))
ans = 0
for i in range(1, n - 1):
if a[i] == 0 and a[i - 1] == 1 and a[i + 1] == 1:
a[i + 1] = 0
ans += 1
print(ans)
``` | output | 1 | 46,219 | 8 | 92,439 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,220 | 8 | 92,440 |
Tags: greedy
Correct Solution:
```
def isdist(li, ind):
return li[ind] == li[ind+2] and li[ind] == 1 and li[ind+1] == 0
n = int(input())
lals = list(map(int, input().split()))
rals = list(reversed(lals))
rl = 0
tl = 0
for i in range(n-2):
if isdist(lals, i):
lals[i+2] = 0
tl += 1
if rals[i]==rals[i+2] and rals[i] == 1 and rals[i+1]==0:
rals[i+2] = 0
rl += 1
print(min(rl, tl))
``` | output | 1 | 46,220 | 8 | 92,441 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,221 | 8 | 92,442 |
Tags: greedy
Correct Solution:
```
N = int(input())
x = list(map(int, input().split()))
ans = 0
for k in range(1, len(x) - 1):
if x[k - 1] == 1 and x[k + 1] == 1 and x[k] == 0:
x[k + 1] = 0
ans += 1
print(ans)
``` | output | 1 | 46,221 | 8 | 92,443 |
Provide tags and a correct Python 3 solution for this coding contest problem.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples. | instruction | 0 | 46,222 | 8 | 92,444 |
Tags: greedy
Correct Solution:
```
def B():
n = int(input())
lights = [int(x) for x in input().split()]
count = 0
for i in range(1,n-1):
if(lights[i-1]==lights[i+1]==1 and lights[i]==0):
lights[i+1]=0
count+=1
print(count)
B()
``` | output | 1 | 46,222 | 8 | 92,445 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
ans = 0
n = int(input())
a = list(map(int, input().split()))
for i in range(1, n - 1):
if a[i] == 0 and a[i - 1] == 1 and a[i + 1] == 1:
a[i + 1] = 0
ans += 1
print(ans)
``` | instruction | 0 | 46,223 | 8 | 92,446 |
Yes | output | 1 | 46,223 | 8 | 92,447 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
conf = []
ans = 0
for i in range(1, n - 1):
if a[i] != a[i - 1] == a[i + 1] == 1:
conf.append(i)
ans += 1
i = 0
while i < len(conf):
if conf[i] - conf[i - 1] == 2:
ans -= 1
conf.pop(i)
conf.pop(i - 1)
i -= 1
i += 1
print(ans)
``` | instruction | 0 | 46,224 | 8 | 92,448 |
Yes | output | 1 | 46,224 | 8 | 92,449 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
from math import ceil
c=1
n=int(input())
a = [int(i) for i in input().split()]
s=[0]*n
p=[]
for i in range(1, n-1):
if a[i]==0 and a[i-1]==1 and a[i+1]==1:
s[i]+=1
#print(s)
t=sum(s)
for i in range(1, n-2):
if s[i]==1 and s[i+2]==1:
c=c+1
else:
if s[i]==1 and s[i+2]!=1 and c>1:
p.append(c)
c=1
if c>1:
p.append(c)
#print(p)
su1=sum(p)
total = t-su1 + ceil(sum(p)/2)
print(total)
``` | instruction | 0 | 46,225 | 8 | 92,450 |
Yes | output | 1 | 46,225 | 8 | 92,451 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
a.reverse()
b = 0
for i in range(1, len(a)-1) :
if a[i] == 0 and a[i - 1] == 1 and a[i + 1] == 1:
a[i + 1] = 0
b += 1
print(b)
``` | instruction | 0 | 46,226 | 8 | 92,452 |
Yes | output | 1 | 46,226 | 8 | 92,453 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
k = int(input())
home = input().split()
ans = 0
for i in range(0, k):
if home[i]=='0':
if 0<i and i<k-1:
if home[i-1]=='1' and home[i+1]=='1':
ans+=1
print(ans//2+ans%2)
``` | instruction | 0 | 46,227 | 8 | 92,454 |
No | output | 1 | 46,227 | 8 | 92,455 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
n= list(map(int,input().split()))
c=0
for i in range(len(n)-2):
if n[i]==1 and n[i+1]==0 and n[i+2]==1:
n[i+2]=0
c=c+1
print(c)
``` | instruction | 0 | 46,228 | 8 | 92,456 |
No | output | 1 | 46,228 | 8 | 92,457 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
n = int (input())
a = list(map(int,input().split()))
b = []
z = 0
y = 0
for i in range (0,n):
for j in range(0,n):
if a[i] == a[j]:
y = y + 1
for i in range(1,len(a)- 1):
if a[i-1]==a[i+1]==1 and a[i]==0:
z = z + 1
b.append(i)
x = 0
for i in range(z):
for j in range(z):
if b[i]==b[j] + 2:
x = x + 1
if x > 1 and x % 2 == 0:
x = x/2
else:
x = x + 1
x = x // 2
z = z - x
if y//n == n:
print(0)
else:print(z)
``` | instruction | 0 | 46,229 | 8 | 92,458 |
No | output | 1 | 46,229 | 8 | 92,459 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
There is a house with n flats situated on the main street of Berlatov. Vova is watching this house every night. The house can be represented as an array of n integer numbers a_1, a_2, ..., a_n, where a_i = 1 if in the i-th flat the light is on and a_i = 0 otherwise.
Vova thinks that people in the i-th flats are disturbed and cannot sleep if and only if 1 < i < n and a_{i - 1} = a_{i + 1} = 1 and a_i = 0.
Vova is concerned by the following question: what is the minimum number k such that if people from exactly k pairwise distinct flats will turn off the lights then nobody will be disturbed? Your task is to find this number k.
Input
The first line of the input contains one integer n (3 ≤ n ≤ 100) — the number of flats in the house.
The second line of the input contains n integers a_1, a_2, ..., a_n (a_i ∈ \{0, 1\}), where a_i is the state of light in the i-th flat.
Output
Print only one integer — the minimum number k such that if people from exactly k pairwise distinct flats will turn off the light then nobody will be disturbed.
Examples
Input
10
1 1 0 1 1 0 1 0 1 0
Output
2
Input
5
1 1 0 0 0
Output
0
Input
4
1 1 1 1
Output
0
Note
In the first example people from flats 2 and 7 or 4 and 7 can turn off the light and nobody will be disturbed. It can be shown that there is no better answer in this example.
There are no disturbed people in second and third examples.
Submitted Solution:
```
n = int(input())
a = list(map(int, input().split()))
mask = [0] * len(a)
for i in range(1, len(a)-1):
if a[i] == 0 and a[i-1] == 1 and a[i+1] == 1:
mask[i] = 1
total = 0
for i in range(1, len(a)-1):
if a[i] == 1 and mask[i-1] and mask[i+1]:
total += 1
a[i] = 0
for i in range(1, len(a) - 1):
if a[i] == 0 and a[i-1] == 1 and a[i+1] == 1:
a[i+1] = 0
total += 1
print(total)
``` | instruction | 0 | 46,230 | 8 | 92,460 |
No | output | 1 | 46,230 | 8 | 92,461 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,247 | 8 | 92,494 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
f=lambda:map(int,input().split());[n,k],arr=f(),list(f());print([i for i in range(n+1)if sum(sorted(arr[:i])[::-2])<=k][-1])
``` | output | 1 | 46,247 | 8 | 92,495 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,248 | 8 | 92,496 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
"""Sorted List
==============
:doc:`Sorted Containers<index>` is an Apache2 licensed Python sorted
collections library, written in pure-Python, and fast as C-extensions. The
:doc:`introduction<introduction>` is the best way to get started.
Sorted list implementations:
.. currentmodule:: sortedcontainers
* :class:`SortedList`
* :class:`SortedKeyList`
"""
# pylint: disable=too-many-lines
from __future__ import print_function
from bisect import bisect_left, bisect_right, insort
from collections import Sequence, MutableSequence
from itertools import chain, repeat, starmap
from math import log
from operator import add, eq, ne, gt, ge, lt, le, iadd
from textwrap import dedent
###############################################################################
# BEGIN Python 2/3 Shims
###############################################################################
from functools import wraps
from sys import hexversion
if hexversion < 0x03000000:
from itertools import imap as map # pylint: disable=redefined-builtin
from itertools import izip as zip # pylint: disable=redefined-builtin
try:
from thread import get_ident
except ImportError:
from dummy_thread import get_ident
else:
from functools import reduce
try:
from _thread import get_ident
except ImportError:
from _dummy_thread import get_ident
def recursive_repr(fillvalue='...'):
"Decorator to make a repr function return fillvalue for a recursive call."
# pylint: disable=missing-docstring
# Copied from reprlib in Python 3
# https://hg.python.org/cpython/file/3.6/Lib/reprlib.py
def decorating_function(user_function):
repr_running = set()
@wraps(user_function)
def wrapper(self):
key = id(self), get_ident()
if key in repr_running:
return fillvalue
repr_running.add(key)
try:
result = user_function(self)
finally:
repr_running.discard(key)
return result
return wrapper
return decorating_function
###############################################################################
# END Python 2/3 Shims
###############################################################################
class SortedList(MutableSequence):
"""Sorted list is a sorted mutable sequence.
Sorted list values are maintained in sorted order.
Sorted list values must be comparable. The total ordering of values must
not change while they are stored in the sorted list.
Methods for adding values:
* :func:`SortedList.add`
* :func:`SortedList.update`
* :func:`SortedList.__add__`
* :func:`SortedList.__iadd__`
* :func:`SortedList.__mul__`
* :func:`SortedList.__imul__`
Methods for removing values:
* :func:`SortedList.clear`
* :func:`SortedList.discard`
* :func:`SortedList.remove`
* :func:`SortedList.pop`
* :func:`SortedList.__delitem__`
Methods for looking up values:
* :func:`SortedList.bisect_left`
* :func:`SortedList.bisect_right`
* :func:`SortedList.count`
* :func:`SortedList.index`
* :func:`SortedList.__contains__`
* :func:`SortedList.__getitem__`
Methods for iterating values:
* :func:`SortedList.irange`
* :func:`SortedList.islice`
* :func:`SortedList.__iter__`
* :func:`SortedList.__reversed__`
Methods for miscellany:
* :func:`SortedList.copy`
* :func:`SortedList.__len__`
* :func:`SortedList.__repr__`
* :func:`SortedList._check`
* :func:`SortedList._reset`
Sorted lists use lexicographical ordering semantics when compared to other
sequences.
Some methods of mutable sequences are not supported and will raise
not-implemented error.
"""
DEFAULT_LOAD_FACTOR = 1000
def __init__(self, iterable=None, key=None):
"""Initialize sorted list instance.
Optional `iterable` argument provides an initial iterable of values to
initialize the sorted list.
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList()
>>> sl
SortedList([])
>>> sl = SortedList([3, 1, 2, 5, 4])
>>> sl
SortedList([1, 2, 3, 4, 5])
:param iterable: initial values (optional)
"""
assert key is None
self._len = 0
self._load = self.DEFAULT_LOAD_FACTOR
self._lists = []
self._maxes = []
self._index = []
self._offset = 0
if iterable is not None:
self._update(iterable)
def __new__(cls, iterable=None, key=None):
"""Create new sorted list or sorted-key list instance.
Optional `key`-function argument will return an instance of subtype
:class:`SortedKeyList`.
>>> sl = SortedList()
>>> isinstance(sl, SortedList)
True
>>> sl = SortedList(key=lambda x: -x)
>>> isinstance(sl, SortedList)
True
>>> isinstance(sl, SortedKeyList)
True
:param iterable: initial values (optional)
:param key: function used to extract comparison key (optional)
:return: sorted list or sorted-key list instance
"""
# pylint: disable=unused-argument
if key is None:
return object.__new__(cls)
else:
if cls is SortedList:
return object.__new__(SortedKeyList)
else:
raise TypeError('inherit SortedKeyList for key argument')
@property
def key(self):
"""Function used to extract comparison key from values.
Sorted list compares values directly so the key function is none.
"""
return None
def _reset(self, load):
"""Reset sorted list load factor.
The `load` specifies the load-factor of the list. The default load
factor of 1000 works well for lists from tens to tens-of-millions of
values. Good practice is to use a value that is the cube root of the
list size. With billions of elements, the best load factor depends on
your usage. It's best to leave the load factor at the default until you
start benchmarking.
See :doc:`implementation` and :doc:`performance-scale` for more
information.
Runtime complexity: `O(n)`
:param int load: load-factor for sorted list sublists
"""
values = reduce(iadd, self._lists, [])
self._clear()
self._load = load
self._update(values)
def clear(self):
"""Remove all values from sorted list.
Runtime complexity: `O(n)`
"""
self._len = 0
del self._lists[:]
del self._maxes[:]
del self._index[:]
self._offset = 0
_clear = clear
def add(self, value):
"""Add `value` to sorted list.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList()
>>> sl.add(3)
>>> sl.add(1)
>>> sl.add(2)
>>> sl
SortedList([1, 2, 3])
:param value: value to add to sorted list
"""
_lists = self._lists
_maxes = self._maxes
if _maxes:
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
pos -= 1
_lists[pos].append(value)
_maxes[pos] = value
else:
insort(_lists[pos], value)
self._expand(pos)
else:
_lists.append([value])
_maxes.append(value)
self._len += 1
def _expand(self, pos):
"""Split sublists with length greater than double the load-factor.
Updates the index when the sublist length is less than double the load
level. This requires incrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
"""
_load = self._load
_lists = self._lists
_index = self._index
if len(_lists[pos]) > (_load << 1):
_maxes = self._maxes
_lists_pos = _lists[pos]
half = _lists_pos[_load:]
del _lists_pos[_load:]
_maxes[pos] = _lists_pos[-1]
_lists.insert(pos + 1, half)
_maxes.insert(pos + 1, half[-1])
del _index[:]
else:
if _index:
child = self._offset + pos
while child:
_index[child] += 1
child = (child - 1) >> 1
_index[0] += 1
def update(self, iterable):
"""Update sorted list by adding all values from `iterable`.
Runtime complexity: `O(k*log(n))` -- approximate.
>>> sl = SortedList()
>>> sl.update([3, 1, 2])
>>> sl
SortedList([1, 2, 3])
:param iterable: iterable of values to add
"""
_lists = self._lists
_maxes = self._maxes
values = sorted(iterable)
if _maxes:
if len(values) * 4 >= self._len:
values.extend(chain.from_iterable(_lists))
values.sort()
self._clear()
else:
_add = self.add
for val in values:
_add(val)
return
_load = self._load
_lists.extend(values[pos:(pos + _load)]
for pos in range(0, len(values), _load))
_maxes.extend(sublist[-1] for sublist in _lists)
self._len = len(values)
del self._index[:]
_update = update
def __contains__(self, value):
"""Return true if `value` is an element of the sorted list.
``sl.__contains__(value)`` <==> ``value in sl``
Runtime complexity: `O(log(n))`
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> 3 in sl
True
:param value: search for value in sorted list
:return: true if `value` in sorted list
"""
_maxes = self._maxes
if not _maxes:
return False
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return False
_lists = self._lists
idx = bisect_left(_lists[pos], value)
return _lists[pos][idx] == value
def discard(self, value):
"""Remove `value` from sorted list if it is a member.
If `value` is not a member, do nothing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> sl.discard(5)
>>> sl.discard(0)
>>> sl == [1, 2, 3, 4]
True
:param value: `value` to discard from sorted list
"""
_maxes = self._maxes
if not _maxes:
return
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
def remove(self, value):
"""Remove `value` from sorted list; `value` must be a member.
If `value` is not a member, raise ValueError.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 3, 4, 5])
>>> sl.remove(5)
>>> sl == [1, 2, 3, 4]
True
>>> sl.remove(0)
Traceback (most recent call last):
...
ValueError: 0 not in list
:param value: `value` to remove from sorted list
:raises ValueError: if `value` is not in sorted list
"""
_maxes = self._maxes
if not _maxes:
raise ValueError('{0!r} not in list'.format(value))
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
raise ValueError('{0!r} not in list'.format(value))
_lists = self._lists
idx = bisect_left(_lists[pos], value)
if _lists[pos][idx] == value:
self._delete(pos, idx)
else:
raise ValueError('{0!r} not in list'.format(value))
def _delete(self, pos, idx):
"""Delete value at the given `(pos, idx)`.
Combines lists that are less than half the load level.
Updates the index when the sublist length is more than half the load
level. This requires decrementing the nodes in a traversal from the
leaf node to the root. For an example traversal see
``SortedList._loc``.
:param int pos: lists index
:param int idx: sublist index
"""
_lists = self._lists
_maxes = self._maxes
_index = self._index
_lists_pos = _lists[pos]
del _lists_pos[idx]
self._len -= 1
len_lists_pos = len(_lists_pos)
if len_lists_pos > (self._load >> 1):
_maxes[pos] = _lists_pos[-1]
if _index:
child = self._offset + pos
while child > 0:
_index[child] -= 1
child = (child - 1) >> 1
_index[0] -= 1
elif len(_lists) > 1:
if not pos:
pos += 1
prev = pos - 1
_lists[prev].extend(_lists[pos])
_maxes[prev] = _lists[prev][-1]
del _lists[pos]
del _maxes[pos]
del _index[:]
self._expand(prev)
elif len_lists_pos:
_maxes[pos] = _lists_pos[-1]
else:
del _lists[pos]
del _maxes[pos]
del _index[:]
def _loc(self, pos, idx):
"""Convert an index pair (lists index, sublist index) into a single
index number that corresponds to the position of the value in the
sorted list.
Many queries require the index be built. Details of the index are
described in ``SortedList._build_index``.
Indexing requires traversing the tree from a leaf node to the root. The
parent of each node is easily computable at ``(pos - 1) // 2``.
Left-child nodes are always at odd indices and right-child nodes are
always at even indices.
When traversing up from a right-child node, increment the total by the
left-child node.
The final index is the sum from traversal and the index in the sublist.
For example, using the index from ``SortedList._build_index``::
_index = 14 5 9 3 2 4 5
_offset = 3
Tree::
14
5 9
3 2 4 5
Converting an index pair (2, 3) into a single index involves iterating
like so:
1. Starting at the leaf node: offset + alpha = 3 + 2 = 5. We identify
the node as a left-child node. At such nodes, we simply traverse to
the parent.
2. At node 9, position 2, we recognize the node as a right-child node
and accumulate the left-child in our total. Total is now 5 and we
traverse to the parent at position 0.
3. Iteration ends at the root.
The index is then the sum of the total and sublist index: 5 + 3 = 8.
:param int pos: lists index
:param int idx: sublist index
:return: index in sorted list
"""
if not pos:
return idx
_index = self._index
if not _index:
self._build_index()
total = 0
# Increment pos to point in the index to len(self._lists[pos]).
pos += self._offset
# Iterate until reaching the root of the index tree at pos = 0.
while pos:
# Right-child nodes are at odd indices. At such indices
# account the total below the left child node.
if not pos & 1:
total += _index[pos - 1]
# Advance pos to the parent node.
pos = (pos - 1) >> 1
return total + idx
def _pos(self, idx):
"""Convert an index into an index pair (lists index, sublist index)
that can be used to access the corresponding lists position.
Many queries require the index be built. Details of the index are
described in ``SortedList._build_index``.
Indexing requires traversing the tree to a leaf node. Each node has two
children which are easily computable. Given an index, pos, the
left-child is at ``pos * 2 + 1`` and the right-child is at ``pos * 2 +
2``.
When the index is less than the left-child, traversal moves to the
left sub-tree. Otherwise, the index is decremented by the left-child
and traversal moves to the right sub-tree.
At a child node, the indexing pair is computed from the relative
position of the child node as compared with the offset and the remaining
index.
For example, using the index from ``SortedList._build_index``::
_index = 14 5 9 3 2 4 5
_offset = 3
Tree::
14
5 9
3 2 4 5
Indexing position 8 involves iterating like so:
1. Starting at the root, position 0, 8 is compared with the left-child
node (5) which it is greater than. When greater the index is
decremented and the position is updated to the right child node.
2. At node 9 with index 3, we again compare the index to the left-child
node with value 4. Because the index is the less than the left-child
node, we simply traverse to the left.
3. At node 4 with index 3, we recognize that we are at a leaf node and
stop iterating.
4. To compute the sublist index, we subtract the offset from the index
of the leaf node: 5 - 3 = 2. To compute the index in the sublist, we
simply use the index remaining from iteration. In this case, 3.
The final index pair from our example is (2, 3) which corresponds to
index 8 in the sorted list.
:param int idx: index in sorted list
:return: (lists index, sublist index) pair
"""
if idx < 0:
last_len = len(self._lists[-1])
if (-idx) <= last_len:
return len(self._lists) - 1, last_len + idx
idx += self._len
if idx < 0:
raise IndexError('list index out of range')
elif idx >= self._len:
raise IndexError('list index out of range')
if idx < len(self._lists[0]):
return 0, idx
_index = self._index
if not _index:
self._build_index()
pos = 0
child = 1
len_index = len(_index)
while child < len_index:
index_child = _index[child]
if idx < index_child:
pos = child
else:
idx -= index_child
pos = child + 1
child = (pos << 1) + 1
return (pos - self._offset, idx)
def _build_index(self):
"""Build a positional index for indexing the sorted list.
Indexes are represented as binary trees in a dense array notation
similar to a binary heap.
For example, given a lists representation storing integers::
0: [1, 2, 3]
1: [4, 5]
2: [6, 7, 8, 9]
3: [10, 11, 12, 13, 14]
The first transformation maps the sub-lists by their length. The
first row of the index is the length of the sub-lists::
0: [3, 2, 4, 5]
Each row after that is the sum of consecutive pairs of the previous
row::
1: [5, 9]
2: [14]
Finally, the index is built by concatenating these lists together::
_index = [14, 5, 9, 3, 2, 4, 5]
An offset storing the start of the first row is also stored::
_offset = 3
When built, the index can be used for efficient indexing into the list.
See the comment and notes on ``SortedList._pos`` for details.
"""
row0 = list(map(len, self._lists))
if len(row0) == 1:
self._index[:] = row0
self._offset = 0
return
head = iter(row0)
tail = iter(head)
row1 = list(starmap(add, zip(head, tail)))
if len(row0) & 1:
row1.append(row0[-1])
if len(row1) == 1:
self._index[:] = row1 + row0
self._offset = 1
return
size = 2 ** (int(log(len(row1) - 1, 2)) + 1)
row1.extend(repeat(0, size - len(row1)))
tree = [row0, row1]
while len(tree[-1]) > 1:
head = iter(tree[-1])
tail = iter(head)
row = list(starmap(add, zip(head, tail)))
tree.append(row)
reduce(iadd, reversed(tree), self._index)
self._offset = size * 2 - 1
def __delitem__(self, index):
"""Remove value at `index` from sorted list.
``sl.__delitem__(index)`` <==> ``del sl[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> del sl[2]
>>> sl
SortedList(['a', 'b', 'd', 'e'])
>>> del sl[:2]
>>> sl
SortedList(['d', 'e'])
:param index: integer or slice for indexing
:raises IndexError: if index out of range
"""
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return self._clear()
elif self._len <= 8 * (stop - start):
values = self._getitem(slice(None, start))
if stop < self._len:
values += self._getitem(slice(stop, None))
self._clear()
return self._update(values)
indices = range(start, stop, step)
# Delete items from greatest index to least so
# that the indices remain valid throughout iteration.
if step > 0:
indices = reversed(indices)
_pos, _delete = self._pos, self._delete
for index in indices:
pos, idx = _pos(index)
_delete(pos, idx)
else:
pos, idx = self._pos(index)
self._delete(pos, idx)
def __getitem__(self, index):
"""Lookup value at `index` in sorted list.
``sl.__getitem__(index)`` <==> ``sl[index]``
Supports slicing.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl[1]
'b'
>>> sl[-1]
'e'
>>> sl[2:5]
['c', 'd', 'e']
:param index: integer or slice for indexing
:return: value or list of values
:raises IndexError: if index out of range
"""
_lists = self._lists
if isinstance(index, slice):
start, stop, step = index.indices(self._len)
if step == 1 and start < stop:
if start == 0 and stop == self._len:
return reduce(iadd, self._lists, [])
start_pos, start_idx = self._pos(start)
if stop == self._len:
stop_pos = len(_lists) - 1
stop_idx = len(_lists[stop_pos])
else:
stop_pos, stop_idx = self._pos(stop)
if start_pos == stop_pos:
return _lists[start_pos][start_idx:stop_idx]
prefix = _lists[start_pos][start_idx:]
middle = _lists[(start_pos + 1):stop_pos]
result = reduce(iadd, middle, prefix)
result += _lists[stop_pos][:stop_idx]
return result
if step == -1 and start > stop:
result = self._getitem(slice(stop + 1, start + 1))
result.reverse()
return result
# Return a list because a negative step could
# reverse the order of the items and this could
# be the desired behavior.
indices = range(start, stop, step)
return list(self._getitem(index) for index in indices)
else:
if self._len:
if index == 0:
return _lists[0][0]
elif index == -1:
return _lists[-1][-1]
else:
raise IndexError('list index out of range')
if 0 <= index < len(_lists[0]):
return _lists[0][index]
len_last = len(_lists[-1])
if -len_last < index < 0:
return _lists[-1][len_last + index]
pos, idx = self._pos(index)
return _lists[pos][idx]
_getitem = __getitem__
def __setitem__(self, index, value):
"""Raise not-implemented error.
``sl.__setitem__(index, value)`` <==> ``sl[index] = value``
:raises NotImplementedError: use ``del sl[index]`` and
``sl.add(value)`` instead
"""
message = 'use ``del sl[index]`` and ``sl.add(value)`` instead'
raise NotImplementedError(message)
def __iter__(self):
"""Return an iterator over the sorted list.
``sl.__iter__()`` <==> ``iter(sl)``
Iterating the sorted list while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return chain.from_iterable(self._lists)
def __reversed__(self):
"""Return a reverse iterator over the sorted list.
``sl.__reversed__()`` <==> ``reversed(sl)``
Iterating the sorted list while adding or deleting values may raise a
:exc:`RuntimeError` or fail to iterate over all values.
"""
return chain.from_iterable(map(reversed, reversed(self._lists)))
def reverse(self):
"""Raise not-implemented error.
Sorted list maintains values in ascending sort order. Values may not be
reversed in-place.
Use ``reversed(sl)`` for an iterator over values in descending sort
order.
Implemented to override `MutableSequence.reverse` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``reversed(sl)`` instead
"""
raise NotImplementedError('use ``reversed(sl)`` instead')
def islice(self, start=None, stop=None, reverse=False):
"""Return an iterator that slices sorted list from `start` to `stop`.
The `start` and `stop` index are treated inclusive and exclusive,
respectively.
Both `start` and `stop` default to `None` which is automatically
inclusive of the beginning and end of the sorted list.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> sl = SortedList('abcdefghij')
>>> it = sl.islice(2, 6)
>>> list(it)
['c', 'd', 'e', 'f']
:param int start: start index (inclusive)
:param int stop: stop index (exclusive)
:param bool reverse: yield values in reverse order
:return: iterator
"""
_len = self._len
if not _len:
return iter(())
start, stop, _ = slice(start, stop).indices(self._len)
if start >= stop:
return iter(())
_pos = self._pos
min_pos, min_idx = _pos(start)
if stop == _len:
max_pos = len(self._lists) - 1
max_idx = len(self._lists[-1])
else:
max_pos, max_idx = _pos(stop)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def _islice(self, min_pos, min_idx, max_pos, max_idx, reverse):
"""Return an iterator that slices sorted list using two index pairs.
The index pairs are (min_pos, min_idx) and (max_pos, max_idx), the
first inclusive and the latter exclusive. See `_pos` for details on how
an index is converted to an index pair.
When `reverse` is `True`, values are yielded from the iterator in
reverse order.
"""
_lists = self._lists
if min_pos > max_pos:
return iter(())
if min_pos == max_pos:
if reverse:
indices = reversed(range(min_idx, max_idx))
return map(_lists[min_pos].__getitem__, indices)
indices = range(min_idx, max_idx)
return map(_lists[min_pos].__getitem__, indices)
next_pos = min_pos + 1
if next_pos == max_pos:
if reverse:
min_indices = range(min_idx, len(_lists[min_pos]))
max_indices = range(max_idx)
return chain(
map(_lists[max_pos].__getitem__, reversed(max_indices)),
map(_lists[min_pos].__getitem__, reversed(min_indices)),
)
min_indices = range(min_idx, len(_lists[min_pos]))
max_indices = range(max_idx)
return chain(
map(_lists[min_pos].__getitem__, min_indices),
map(_lists[max_pos].__getitem__, max_indices),
)
if reverse:
min_indices = range(min_idx, len(_lists[min_pos]))
sublist_indices = range(next_pos, max_pos)
sublists = map(_lists.__getitem__, reversed(sublist_indices))
max_indices = range(max_idx)
return chain(
map(_lists[max_pos].__getitem__, reversed(max_indices)),
chain.from_iterable(map(reversed, sublists)),
map(_lists[min_pos].__getitem__, reversed(min_indices)),
)
min_indices = range(min_idx, len(_lists[min_pos]))
sublist_indices = range(next_pos, max_pos)
sublists = map(_lists.__getitem__, sublist_indices)
max_indices = range(max_idx)
return chain(
map(_lists[min_pos].__getitem__, min_indices),
chain.from_iterable(sublists),
map(_lists[max_pos].__getitem__, max_indices),
)
def irange(self, minimum=None, maximum=None, inclusive=(True, True),
reverse=False):
"""Create an iterator of values between `minimum` and `maximum`.
Both `minimum` and `maximum` default to `None` which is automatically
inclusive of the beginning and end of the sorted list.
The argument `inclusive` is a pair of booleans that indicates whether
the minimum and maximum ought to be included in the range,
respectively. The default is ``(True, True)`` such that the range is
inclusive of both minimum and maximum.
When `reverse` is `True` the values are yielded from the iterator in
reverse order; `reverse` defaults to `False`.
>>> sl = SortedList('abcdefghij')
>>> it = sl.irange('c', 'f')
>>> list(it)
['c', 'd', 'e', 'f']
:param minimum: minimum value to start iterating
:param maximum: maximum value to stop iterating
:param inclusive: pair of booleans
:param bool reverse: yield values in reverse order
:return: iterator
"""
_maxes = self._maxes
if not _maxes:
return iter(())
_lists = self._lists
# Calculate the minimum (pos, idx) pair. By default this location
# will be inclusive in our calculation.
if minimum is None:
min_pos = 0
min_idx = 0
else:
if inclusive[0]:
min_pos = bisect_left(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_left(_lists[min_pos], minimum)
else:
min_pos = bisect_right(_maxes, minimum)
if min_pos == len(_maxes):
return iter(())
min_idx = bisect_right(_lists[min_pos], minimum)
# Calculate the maximum (pos, idx) pair. By default this location
# will be exclusive in our calculation.
if maximum is None:
max_pos = len(_maxes) - 1
max_idx = len(_lists[max_pos])
else:
if inclusive[1]:
max_pos = bisect_right(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_right(_lists[max_pos], maximum)
else:
max_pos = bisect_left(_maxes, maximum)
if max_pos == len(_maxes):
max_pos -= 1
max_idx = len(_lists[max_pos])
else:
max_idx = bisect_left(_lists[max_pos], maximum)
return self._islice(min_pos, min_idx, max_pos, max_idx, reverse)
def __len__(self):
"""Return the size of the sorted list.
``sl.__len__()`` <==> ``len(sl)``
:return: size of sorted list
"""
return self._len
def bisect_left(self, value):
"""Return an index to insert `value` in the sorted list.
If the `value` is already present, the insertion point will be before
(to the left of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([10, 11, 12, 13, 14])
>>> sl.bisect_left(12)
2
:param value: insertion index of value in sorted list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_left(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_left(self._lists[pos], value)
return self._loc(pos, idx)
def bisect_right(self, value):
"""Return an index to insert `value` in the sorted list.
Similar to `bisect_left`, but if `value` is already present, the
insertion point with be after (to the right of) any existing values.
Similar to the `bisect` module in the standard library.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([10, 11, 12, 13, 14])
>>> sl.bisect_right(12)
3
:param value: insertion index of value in sorted list
:return: index
"""
_maxes = self._maxes
if not _maxes:
return 0
pos = bisect_right(_maxes, value)
if pos == len(_maxes):
return self._len
idx = bisect_right(self._lists[pos], value)
return self._loc(pos, idx)
bisect = bisect_right
_bisect_right = bisect_right
def count(self, value):
"""Return number of occurrences of `value` in the sorted list.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
>>> sl.count(3)
3
:param value: value to count in sorted list
:return: count
"""
_maxes = self._maxes
if not _maxes:
return 0
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
return 0
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
pos_right = bisect_right(_maxes, value)
if pos_right == len(_maxes):
return self._len - self._loc(pos_left, idx_left)
idx_right = bisect_right(_lists[pos_right], value)
if pos_left == pos_right:
return idx_right - idx_left
right = self._loc(pos_right, idx_right)
left = self._loc(pos_left, idx_left)
return right - left
def copy(self):
"""Return a shallow copy of the sorted list.
Runtime complexity: `O(n)`
:return: new sorted list
"""
return self.__class__(self)
__copy__ = copy
def append(self, value):
"""Raise not-implemented error.
Implemented to override `MutableSequence.append` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``sl.add(value)`` instead
"""
raise NotImplementedError('use ``sl.add(value)`` instead')
def extend(self, values):
"""Raise not-implemented error.
Implemented to override `MutableSequence.extend` which provides an
erroneous default implementation.
:raises NotImplementedError: use ``sl.update(values)`` instead
"""
raise NotImplementedError('use ``sl.update(values)`` instead')
def insert(self, index, value):
"""Raise not-implemented error.
:raises NotImplementedError: use ``sl.add(value)`` instead
"""
raise NotImplementedError('use ``sl.add(value)`` instead')
def pop(self, index=-1):
"""Remove and return value at `index` in sorted list.
Raise :exc:`IndexError` if the sorted list is empty or index is out of
range.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl.pop()
'e'
>>> sl.pop(2)
'c'
>>> sl
SortedList(['a', 'b', 'd'])
:param int index: index of value (default -1)
:return: value
:raises IndexError: if index is out of range
"""
if not self._len:
raise IndexError('pop index out of range')
_lists = self._lists
if index == 0:
val = _lists[0][0]
self._delete(0, 0)
return val
if index == -1:
pos = len(_lists) - 1
loc = len(_lists[pos]) - 1
val = _lists[pos][loc]
self._delete(pos, loc)
return val
if 0 <= index < len(_lists[0]):
val = _lists[0][index]
self._delete(0, index)
return val
len_last = len(_lists[-1])
if -len_last < index < 0:
pos = len(_lists) - 1
loc = len_last + index
val = _lists[pos][loc]
self._delete(pos, loc)
return val
pos, idx = self._pos(index)
val = _lists[pos][idx]
self._delete(pos, idx)
return val
def index(self, value, start=None, stop=None):
"""Return first index of value in sorted list.
Raise ValueError if `value` is not present.
Index must be between `start` and `stop` for the `value` to be
considered present. The default value, None, for `start` and `stop`
indicate the beginning and end of the sorted list.
Negative indices are supported.
Runtime complexity: `O(log(n))` -- approximate.
>>> sl = SortedList('abcde')
>>> sl.index('d')
3
>>> sl.index('z')
Traceback (most recent call last):
...
ValueError: 'z' is not in list
:param value: value in sorted list
:param int start: start index (default None, start of sorted list)
:param int stop: stop index (default None, end of sorted list)
:return: index of value
:raises ValueError: if value is not present
"""
_len = self._len
if not _len:
raise ValueError('{0!r} is not in list'.format(value))
if start is None:
start = 0
if start < 0:
start += _len
if start < 0:
start = 0
if stop is None:
stop = _len
if stop < 0:
stop += _len
if stop > _len:
stop = _len
if stop <= start:
raise ValueError('{0!r} is not in list'.format(value))
_maxes = self._maxes
pos_left = bisect_left(_maxes, value)
if pos_left == len(_maxes):
raise ValueError('{0!r} is not in list'.format(value))
_lists = self._lists
idx_left = bisect_left(_lists[pos_left], value)
if _lists[pos_left][idx_left] != value:
raise ValueError('{0!r} is not in list'.format(value))
stop -= 1
left = self._loc(pos_left, idx_left)
if start <= left:
if left <= stop:
return left
else:
right = self._bisect_right(value) - 1
if start <= right:
return start
raise ValueError('{0!r} is not in list'.format(value))
def __add__(self, other):
"""Return new sorted list containing all values in both sequences.
``sl.__add__(other)`` <==> ``sl + other``
Values in `other` do not need to be in sorted order.
Runtime complexity: `O(n*log(n))`
>>> sl1 = SortedList('bat')
>>> sl2 = SortedList('cat')
>>> sl1 + sl2
SortedList(['a', 'a', 'b', 'c', 't', 't'])
:param other: other iterable
:return: new sorted list
"""
values = reduce(iadd, self._lists, [])
values.extend(other)
return self.__class__(values)
__radd__ = __add__
def __iadd__(self, other):
"""Update sorted list with values from `other`.
``sl.__iadd__(other)`` <==> ``sl += other``
Values in `other` do not need to be in sorted order.
Runtime complexity: `O(k*log(n))` -- approximate.
>>> sl = SortedList('bat')
>>> sl += 'cat'
>>> sl
SortedList(['a', 'a', 'b', 'c', 't', 't'])
:param other: other iterable
:return: existing sorted list
"""
self._update(other)
return self
def __mul__(self, num):
"""Return new sorted list with `num` shallow copies of values.
``sl.__mul__(num)`` <==> ``sl * num``
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList('abc')
>>> sl * 3
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
:param int num: count of shallow copies
:return: new sorted list
"""
values = reduce(iadd, self._lists, []) * num
return self.__class__(values)
__rmul__ = __mul__
def __imul__(self, num):
"""Update the sorted list with `num` shallow copies of values.
``sl.__imul__(num)`` <==> ``sl *= num``
Runtime complexity: `O(n*log(n))`
>>> sl = SortedList('abc')
>>> sl *= 3
>>> sl
SortedList(['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c'])
:param int num: count of shallow copies
:return: existing sorted list
"""
values = reduce(iadd, self._lists, []) * num
self._clear()
self._update(values)
return self
def __make_cmp(seq_op, symbol, doc):
"Make comparator method."
def comparer(self, other):
"Compare method for sorted list and sequence."
if not isinstance(other, Sequence):
return NotImplemented
self_len = self._len
len_other = len(other)
if self_len != len_other:
if seq_op is eq:
return False
if seq_op is ne:
return True
for alpha, beta in zip(self, other):
if alpha != beta:
return seq_op(alpha, beta)
return seq_op(self_len, len_other)
seq_op_name = seq_op.__name__
comparer.__name__ = '__{0}__'.format(seq_op_name)
doc_str = """Return true if and only if sorted list is {0} `other`.
``sl.__{1}__(other)`` <==> ``sl {2} other``
Comparisons use lexicographical order as with sequences.
Runtime complexity: `O(n)`
:param other: `other` sequence
:return: true if sorted list is {0} `other`
"""
comparer.__doc__ = dedent(doc_str.format(doc, seq_op_name, symbol))
return comparer
__eq__ = __make_cmp(eq, '==', 'equal to')
__ne__ = __make_cmp(ne, '!=', 'not equal to')
__lt__ = __make_cmp(lt, '<', 'less than')
__gt__ = __make_cmp(gt, '>', 'greater than')
__le__ = __make_cmp(le, '<=', 'less than or equal to')
__ge__ = __make_cmp(ge, '>=', 'greater than or equal to')
__make_cmp = staticmethod(__make_cmp)
@recursive_repr()
def __repr__(self):
"""Return string representation of sorted list.
``sl.__repr__()`` <==> ``repr(sl)``
:return: string representation
"""
return '{0}({1!r})'.format(type(self).__name__, list(self))
def _check(self):
"""Check invariants of sorted list.
Runtime complexity: `O(n)`
"""
try:
assert self._load >= 4
assert len(self._maxes) == len(self._lists)
assert self._len == sum(len(sublist) for sublist in self._lists)
# Check all sublists are sorted.
for sublist in self._lists:
for pos in range(1, len(sublist)):
assert sublist[pos - 1] <= sublist[pos]
# Check beginning/end of sublists are sorted.
for pos in range(1, len(self._lists)):
assert self._lists[pos - 1][-1] <= self._lists[pos][0]
# Check _maxes index is the last value of each sublist.
for pos in range(len(self._maxes)):
assert self._maxes[pos] == self._lists[pos][-1]
# Check sublist lengths are less than double load-factor.
double = self._load << 1
assert all(len(sublist) <= double for sublist in self._lists)
# Check sublist lengths are greater than half load-factor for all
# but the last sublist.
half = self._load >> 1
for pos in range(0, len(self._lists) - 1):
assert len(self._lists[pos]) >= half
if self._index:
assert self._len == self._index[0]
assert len(self._index) == self._offset + len(self._lists)
# Check index leaf nodes equal length of sublists.
for pos in range(len(self._lists)):
leaf = self._index[self._offset + pos]
assert leaf == len(self._lists[pos])
# Check index branch nodes are the sum of their children.
for pos in range(self._offset):
child = (pos << 1) + 1
if child >= len(self._index):
assert self._index[pos] == 0
elif child + 1 == len(self._index):
assert self._index[pos] == self._index[child]
else:
child_sum = self._index[child] + self._index[child + 1]
assert child_sum == self._index[pos]
except:
import sys
import traceback
traceback.print_exc(file=sys.stdout)
print('len', self._len)
print('load', self._load)
print('offset', self._offset)
print('len_index', len(self._index))
print('index', self._index)
print('len_maxes', len(self._maxes))
print('maxes', self._maxes)
print('len_lists', len(self._lists))
print('lists', self._lists)
raise
def identity(value):
"Identity function."
return value
n, m = map(int, input().split())
s = [int(i) for i in input().split()]
a = SortedList()
a.add(s[0])
f = False
for i in range(1, n):
a.add(s[i])
j = 0
curh = 0
if i % 2 != 0:
while j <= i:
if j == i:
curh += a[j]
else:
curh += a[j + 1]
j += 2
if curh > m:
break
if curh > m:
break
else:
while j <= i:
if j == i:
curh += a[j]
else:
curh += a[j + 1]
j += 2
if curh > m:
break
if curh > m:
curh = a[0]
j = 1
while j <= i:
if j == i:
curh += a[j]
else:
curh += a[j + 1]
j += 2
if curh > m:
break
if curh > m:
break
else:
f = True
print(n)
if not f:
print(len(a) - 1)
``` | output | 1 | 46,248 | 8 | 92,497 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,249 | 8 | 92,498 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
a,b=map(int,input().split())
z=list(map(int,input().split()));s=0
for i in range(a+1):
if sum(sorted(z[:i])[::-2])<=b:s=i
print(s)
``` | output | 1 | 46,249 | 8 | 92,499 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,250 | 8 | 92,500 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
n, h = map(int, input().split())
a = list(map(int, input().split()))
n += 1
a.append(1000000000)
for i in range(n):
s = 0
lst = sorted(a[:i + 1])
ln = len(lst)
for j in range(ln - 1, -1, -2):
s += lst[j]
if s > h:
print(i)
break
``` | output | 1 | 46,250 | 8 | 92,501 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,251 | 8 | 92,502 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 5 03:18:51 2020
@author: Dark Soul
"""
[n,h]=list(map(int,input().split()))
a=list(map(int,input().split()))
for sol in range(n,-1,-1):
b=a[0:sol]
b.sort()
s=0
for i in range(len(b)-1,-1,-2):
s+=b[i]
if s<=h:
break
print(sol)
``` | output | 1 | 46,251 | 8 | 92,503 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,252 | 8 | 92,504 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
n,h=[int(j) for j in input().split()]
a=[int(j) for j in input().split()]
b=[0 for j in range(n)]
if(a[0]<=h):
b[0]=a[0]
d=0
e=-1
for i in range(1,n):
d=0
j = i-1
key = a[i]
while j >=0 and key < b[j] :
b[j+1] = b[j]
j -= 1
b[j+1] = key
if((i+1)%2==0):
for j in range(1,i+1,2):
d=d+b[j]
else:
for j in range(0,i+1,2):
d=d+b[j]
if(d>h):
e=i
break
if(e==-1):
print(n)
else:
print(e)
``` | output | 1 | 46,252 | 8 | 92,505 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,253 | 8 | 92,506 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
import math
from bisect import insort
from collections import deque, defaultdict
from sys import stdin, stdout
input = stdin.readline
# print = stdout.write
listin = lambda : list(map(int, input().split()))
mapin = lambda : map(int, input().split())
n, h = mapin()
a = listin()
s = []
for i in a:
insort(s, i)
if sum(s[n-1::-2]) > h:
print(len(s)-1)
exit()
print(n)
``` | output | 1 | 46,253 | 8 | 92,507 |
Provide tags and a correct Python 3 solution for this coding contest problem.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image> | instruction | 0 | 46,254 | 8 | 92,508 |
Tags: binary search, flows, greedy, sortings
Correct Solution:
```
n, h = map(int, input().strip().split())
arr = list(map(int, input().strip().split()))
for k in range(n, 0, -1):
temp = sorted(arr[:k], reverse=True)
if sum(temp[::2]) <= h:
print(k)
break
``` | output | 1 | 46,254 | 8 | 92,509 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
f=lambda:map(int,input().split());(n,k),a=f(),[*f()]
while sum(sorted(a[:n])[-1::-2])>k:n-=1
print(n)
``` | instruction | 0 | 46,255 | 8 | 92,510 |
Yes | output | 1 | 46,255 | 8 | 92,511 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
def is_possible(num):
global h, array
copy = array[:num]
copy = sorted(copy)
res = h
for i in range(len(copy) - 1, -1, -2):
res -= copy[i]
return res >= 0
amount, h = [int(s) for s in input().split()]
array = [int(s) for s in input().split()]
#array = sorted(array)
#print(array)
left = -1
right = int(10 ** 18)
while right - left > 1:
middle = (right + left) // 2
if is_possible(middle):
left = middle
else:
right = middle
if left > amount:
print(amount)
else:
print(left)
#print(is_possible(3))
``` | instruction | 0 | 46,256 | 8 | 92,512 |
Yes | output | 1 | 46,256 | 8 | 92,513 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
#Bhargey Mehta (Sophomore)
#DA-IICT, Gandhinagar
import sys, math, queue
sys.setrecursionlimit(1000000)
#sys.stdin = open("input.txt", "r")
def canPut(k, height, bot):
bot.sort(reverse=True)
#print(bot)
for i in range(k):
if bot[i] > height:
return False
if i%2 == 1:
height -= bot[i-1]
return True
n, height = map(int, input().split())
bot = list(map(int, input().split()))
l, h = 1, n
while l <= h:
m = (l+h)//2
if canPut(m, height, bot[:m]):
ans = m
l = m+1
else:
h = m-1
print(ans)
``` | instruction | 0 | 46,257 | 8 | 92,514 |
Yes | output | 1 | 46,257 | 8 | 92,515 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
n, h = [int(x) for x in input().split(" ")]
a = [int(x) for x in input().split(" ")]
m = n
for i in range(0, n):
nok = False
b = a[0:i+1]
b.sort()
if i % 2 != 0:
s = 0
for j in range(1, i+1, 2):
if s+b[j] > h:
nok = True
break
else:
s += b[j]
else:
s = 0
for j in range(0, i+1, 2):
if s+b[j] > h:
nok = True
break
else:
s += b[j]
if nok:
m = i
break
print(m)
``` | instruction | 0 | 46,258 | 8 | 92,516 |
Yes | output | 1 | 46,258 | 8 | 92,517 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
n, h = [int(i) for i in input().split()]
alturas = [int(i) for i in input().split()]
for i in range(1,n + 1):
lista = alturas[0:i]
lista.sort(reverse=True)
novaLista = lista[::2]
if(sum(novaLista)<=h):
print(i)
``` | instruction | 0 | 46,259 | 8 | 92,518 |
No | output | 1 | 46,259 | 8 | 92,519 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
R=lambda:map(int,input().split())
n,h=R()
a=list(R())
y=[]
k=1
for i in range(1,n):
y=a[:i+1]
y.sort(reverse=True)
s=sum(y[::2])
if(h>=s):
k=i
else:
break
print(k)
``` | instruction | 0 | 46,260 | 8 | 92,520 |
No | output | 1 | 46,260 | 8 | 92,521 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
from sys import stdin
n,m=map(int,stdin.readline().strip().split())
s1=list(map(int,stdin.readline().strip().split()))
def can(s):
ans=0
x=0
h=0
s.sort()
while x<len(s):
if x==len(s)-3:
a=s[x]
if h+a<=m:
ans+=1
h=h+a
else:
return False
x+=1
elif x==len(s)-1:
a=s[x]
if h+a<=m:
ans+=1
h=h+a
else:
return False
x+=1
else:
a=min(s[x],s[x+1])
b=max(s[x+1],s[x])
if h+b<=m:
ans+=2
h+=b
else:
return False
x+=2
return True
ans=0
for i in range(1,n+1):
if can(s1[0:i]):
ans+=1
else:
break
print(ans)
``` | instruction | 0 | 46,261 | 8 | 92,522 |
No | output | 1 | 46,261 | 8 | 92,523 |
Evaluate the correctness of the submitted Python 3 solution to the coding contest problem. Provide a "Yes" or "No" response.
Alyona has recently bought a miniature fridge that can be represented as a matrix with h rows and 2 columns. Initially there is only one shelf at the bottom of the fridge, but Alyona can install arbitrary number of shelves inside the fridge between any two rows. A shelf is two cells wide, does not occupy any space but separates the inside of the fridge to the lower and upper part.
<image> An example of a fridge with h = 7 and two shelves. The shelves are shown in black. The picture corresponds to the first example.
Alyona has n bottles of milk that she wants to put in the fridge. The i-th bottle is a_i cells tall and 1 cell wide. She can put a bottle on some shelf if the corresponding space above the shelf is at least as tall as the bottle. She can not put a bottle on top of another bottle (if there is no shelf between them). Two bottles can not share a cell.
Alyona is interested in the largest integer k such that she can put bottles 1, 2, ..., k in the fridge at the same time. Find this largest k.
Input
The first line contains two integers n and h (1 ≤ n ≤ 10^3, 1 ≤ h ≤ 10^9) — the number of bottles and the height of the fridge.
The second line contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ h) — the heights of the bottles.
Output
Print the single integer k — the maximum integer such that Alyona can put the bottles 1, 2, ..., k in the fridge at the same time. If Alyona can put all bottles in the fridge, print n. It is easy to see that Alyona can always put at least one bottle in the fridge.
Examples
Input
5 7
2 3 5 4 1
Output
3
Input
10 10
9 1 1 1 1 1 1 1 1 1
Output
4
Input
5 10
3 1 4 2 4
Output
5
Note
One of optimal locations in the first example is shown on the picture in the statement.
One of optimal locations in the second example is shown on the picture below.
<image>
One of optimal locations in the third example is shown on the picture below.
<image>
Submitted Solution:
```
def solve():
n, h = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
def good(x):
y = h
if x > n:
return False
b = a[:x]
b.sort()
while b and y:
z = b.pop()
if b:
b.pop()
y -= z
return not b and not y
l = 0
r = n + 1
while r - l > 1:
m = (l + r) // 2
if good(m):
l = m
else:
r = m
return l
print(solve())
``` | instruction | 0 | 46,262 | 8 | 92,524 |
No | output | 1 | 46,262 | 8 | 92,525 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,382 | 8 | 92,764 |
Tags: greedy, implementation
Correct Solution:
```
s = int(input())
res = []
for i in range(s):
n,d = map(int,input().split())
ls = list(map(int,input().split()))
if n == 1:
rs = ls[0]
else:
# add = 0
for index,value in enumerate(ls[1:]):
if d >= (index+1)*value:
ls[0] += ls[index+1]
d -= (index+1)*value
else:
# print(ls[0])
ls[0] = ls[0] + d//(index+1)
# print(ls[0])
break
# print(value)
rs = ls[0]
res.append(rs)
for i in res:
print(i)
``` | output | 1 | 46,382 | 8 | 92,765 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,383 | 8 | 92,766 |
Tags: greedy, implementation
Correct Solution:
```
import string
def main():
n, d = map(int, input().split())
lst = list(map(int, input().split()))
amm = 0
for i in range(1, len(lst)):
if lst[i] > 0 and d > 0:
if i <= d and lst[i] > 0:
moves = min(d // i, lst[i])
amm += moves
d -= (moves * i)
else:
break
print(amm + lst[0])
if __name__ == "__main__":
t = int(input())
for i in range(t):
main()
``` | output | 1 | 46,383 | 8 | 92,767 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,384 | 8 | 92,768 |
Tags: greedy, implementation
Correct Solution:
```
q = int(input())
for z in range(0, q):
n = (list(map(int, input().split())))
a = (list(map(int, input().split())))
j = 0
p = 0
l=0
for i in range(1, n[0]):
l += i * a[i]
if l > n[1]:
j = 1
break
p += a[i]
if j==1:
l=l-(i*a[i])
for w in range(1,a[i]+1):
if (i*w)>n[1]-l:
break
p=p+a[0]
if j==1:
p=p+w-1
print(p)
``` | output | 1 | 46,384 | 8 | 92,769 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,385 | 8 | 92,770 |
Tags: greedy, implementation
Correct Solution:
```
# -*- coding: utf-8 -*-
"""Untitled24.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1QWkwmsVnz3H_tV0j03L72uorR_HrTjYJ
"""
for _ in range(int(input())):
m,n=input().split()
m=int(m)
n=int(n)
x=[int(x) for x in input().split()]
for i in range(1,len(x)):
if x[i]>int(n/i):
x[0]+=int(n/i)
n=n-int(n/i)
break
else:
x[0]+=x[i]
n=n-x[i]*i
print(x[0])
``` | output | 1 | 46,385 | 8 | 92,771 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,386 | 8 | 92,772 |
Tags: greedy, implementation
Correct Solution:
```
def solve():
n, d = map(int, input().split())
a = list(map(int, input().split()))
for i in range(d):
for j in range(1, n):
if a[j] > 0:
a[j] -= 1
a[j - 1] += 1
break
print(a[0])
t = int(input())
for _ in range(t):
solve()
``` | output | 1 | 46,386 | 8 | 92,773 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,387 | 8 | 92,774 |
Tags: greedy, implementation
Correct Solution:
```
import sys
import math
from collections import defaultdict
from collections import deque
from itertools import combinations
from itertools import permutations
input = lambda : sys.stdin.readline().rstrip()
read = lambda : list(map(int, input().split()))
go = lambda : 1/0
def write(*args, sep="\n"):
for i in args:
sys.stdout.write("{}{}".format(i, sep))
INF = float('inf')
MOD = int(1e9 + 7)
YES = "YES"
NO = "NO"
for _ in range(int(input())):
try:
n, d = read()
arr = read()
if n == 1:
print(arr[0])
go()
for i in range(d):
for j in range(1, n):
if arr[j] > 0:
arr[j - 1] += 1
arr[j] -= 1
break
print(arr[0])
except ZeroDivisionError:
continue
except Exception as e:
print(e)
continue
``` | output | 1 | 46,387 | 8 | 92,775 |
Provide tags and a correct Python 3 solution for this coding contest problem.
The USA Construction Operation (USACO) recently ordered Farmer John to arrange a row of n haybale piles on the farm. The i-th pile contains a_i haybales.
However, Farmer John has just left for vacation, leaving Bessie all on her own. Every day, Bessie the naughty cow can choose to move one haybale in any pile to an adjacent pile. Formally, in one day she can choose any two indices i and j (1 ≤ i, j ≤ n) such that |i-j|=1 and a_i>0 and apply a_i = a_i - 1, a_j = a_j + 1. She may also decide to not do anything on some days because she is lazy.
Bessie wants to maximize the number of haybales in pile 1 (i.e. to maximize a_1), and she only has d days to do so before Farmer John returns. Help her find the maximum number of haybales that may be in pile 1 if she acts optimally!
Input
The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. Next 2t lines contain a description of test cases — two lines per test case.
The first line of each test case contains integers n and d (1 ≤ n,d ≤ 100) — the number of haybale piles and the number of days, respectively.
The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 100) — the number of haybales in each pile.
Output
For each test case, output one integer: the maximum number of haybales that may be in pile 1 after d days if Bessie acts optimally.
Example
Input
3
4 5
1 0 3 2
2 2
100 1
1 8
0
Output
3
101
0
Note
In the first test case of the sample, this is one possible way Bessie can end up with 3 haybales in pile 1:
* On day one, move a haybale from pile 3 to pile 2
* On day two, move a haybale from pile 3 to pile 2
* On day three, move a haybale from pile 2 to pile 1
* On day four, move a haybale from pile 2 to pile 1
* On day five, do nothing
In the second test case of the sample, Bessie can do nothing on the first day and move a haybale from pile 2 to pile 1 on the second day. | instruction | 0 | 46,388 | 8 | 92,776 |
Tags: greedy, implementation
Correct Solution:
```
import math as mt
import bisect
#input=sys.stdin.readline
t=int(input())
import collections
import heapq
#t=1
p=10**9+7
def ncr_util():
inv[0]=inv[1]=1
fact[0]=fact[1]=1
for i in range(2,300001):
inv[i]=(inv[i%p]*(p-p//i))%p
for i in range(1,300001):
inv[i]=(inv[i-1]*inv[i])%p
fact[i]=(fact[i-1]*i)%p
def solve(n,d):
ans=l[0]
for j in range(1,n):
while l[j]>0 and d-j>=0:
d-=j
ans+=1
l[j]-=1
return ans
for _ in range(t):
#n=int(input())
#s=input()
#n=int(input())
n,d=(map(int,input().split()))
#n1=n
#a=int(input())
#b=int(input())
#x,y,z=map(int,input().split())
l=list(map(int,input().split()))
#n,b=map(int,input().split())
#n=int(input())
#s=input()
#s1=input()
#p=input()
#l=list(map(int,input().split()))
#l.sort(revrese=True)
#l2=list(map(int,input().split()))
#l=str(n)
#l.sort(reverse=True)
#l2.sort(reverse=True)
#l1.sort(reverse=True)
#print(ans)
print(solve(n,d))
``` | output | 1 | 46,388 | 8 | 92,777 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.